Java Code Examples for java.util.function.IntPredicate#test()

@Override
public final IntStream filter(IntPredicate predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(int t) {
                    if (predicate.test(t))
                        downstream.accept(t);
                }
            };
        }
    };
}
 

@Override
public final IntStream filter(IntPredicate predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(int t) {
                    if (predicate.test(t))
                        downstream.accept(t);
                }
            };
        }
    };
}
 

/**
 * Constructs a quantified predicate matcher for an {@code IntStream}.
 *
 * @param predicate the {@code Predicate} to apply to stream elements
 * @param matchKind the kind of quantified match (all, any, none)
 * @return a {@code TerminalOp} implementing the desired quantified match
 *         criteria
 */
public static TerminalOp<Integer, Boolean> makeInt(IntPredicate predicate,
                                                   MatchKind matchKind) {
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(matchKind);
    class MatchSink extends BooleanTerminalSink<Integer> implements Sink.OfInt {
        MatchSink() {
            super(matchKind);
        }

        @Override
        public void accept(int t) {
            if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
                stop = true;
                value = matchKind.shortCircuitResult;
            }
        }
    }

    return new MatchOp<>(StreamShape.INT_VALUE, matchKind, MatchSink::new);
}
 

/**
 * Constructs a quantified predicate matcher for an {@code IntStream}.
 *
 * @param predicate the {@code Predicate} to apply to stream elements
 * @param matchKind the kind of quantified match (all, any, none)
 * @return a {@code TerminalOp} implementing the desired quantified match
 *         criteria
 */
public static TerminalOp<Integer, Boolean> makeInt(IntPredicate predicate,
                                                   MatchKind matchKind) {
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(matchKind);
    class MatchSink extends BooleanTerminalSink<Integer> implements Sink.OfInt {
        MatchSink() {
            super(matchKind);
        }

        @Override
        public void accept(int t) {
            if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
                stop = true;
                value = matchKind.shortCircuitResult;
            }
        }
    }

    return new MatchOp<>(StreamShape.INT_VALUE, matchKind, MatchSink::new);
}
 

@Override
public final IntStream filter(IntPredicate predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(int t) {
                    if (predicate.test(t))
                        downstream.accept(t);
                }
            };
        }
    };
}
 

/**
 * Constructs a quantified predicate matcher for an {@code IntStream}.
 *
 * @param predicate the {@code Predicate} to apply to stream elements
 * @param matchKind the kind of quantified match (all, any, none)
 * @return a {@code TerminalOp} implementing the desired quantified match
 *         criteria
 */
public static TerminalOp<Integer, Boolean> makeInt(IntPredicate predicate,
                                                   MatchKind matchKind) {
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(matchKind);
    class MatchSink extends BooleanTerminalSink<Integer> implements Sink.OfInt {
        MatchSink() {
            super(matchKind);
        }

        @Override
        public void accept(int t) {
            if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
                stop = true;
                value = matchKind.shortCircuitResult;
            }
        }
    }

    return new MatchOp<>(StreamShape.INT_VALUE, matchKind, MatchSink::new);
}
 

@Override
public final IntStream filter(IntPredicate predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(int t) {
                    if (predicate.test(t))
                        downstream.accept(t);
                }
            };
        }
    };
}
 

/**
 * Constructs a quantified predicate matcher for an {@code IntStream}.
 *
 * @param predicate the {@code Predicate} to apply to stream elements
 * @param matchKind the kind of quantified match (all, any, none)
 * @return a {@code TerminalOp} implementing the desired quantified match
 *         criteria
 */
public static TerminalOp<Integer, Boolean> makeInt(IntPredicate predicate,
                                                   MatchKind matchKind) {
    Objects.requireNonNull(predicate);
    Objects.requireNonNull(matchKind);
    class MatchSink extends BooleanTerminalSink<Integer> implements Sink.OfInt {
        MatchSink() {
            super(matchKind);
        }

        @Override
        public void accept(int t) {
            if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
                stop = true;
                value = matchKind.shortCircuitResult;
            }
        }
    }

    return new MatchOp<>(StreamShape.INT_VALUE, matchKind, MatchSink::new);
}
 

@Override
public final IntStream filter(IntPredicate predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<Integer>(this, StreamShape.INT_VALUE,
                                    StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<Integer> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedInt<Integer>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(int t) {
                    if (predicate.test(t))
                        downstream.accept(t);
                }
            };
        }
    };
}
 

public static LogicalConstant getIntegerConstant(String string,
		IntPredicate filter) {
	if (NUMBER.matches(string) && filter.test(Integer.valueOf(string))) {
		return LogicalConstant.create(Integer.valueOf(string).toString(),
				LogicLanguageServices.getNumeralType(), true);
	} else {
		return null;
	}
}
 

private static Term star(IntPredicate predicate) {
    return (string, start) -> {
        int i = start;
        while (i < string.length()) {
            int codePoint = string.codePointAt(i);
            if (predicate.test(codePoint)) {
                i += Character.charCount(codePoint);
                continue;
            }
            break;
        }
        return Optional.of(new MatchRegion(start, i));
    };
}
 

/**
 * Returns the value of the system property with the specified name as int, or
 * the <code>defaultValue</code> if any of the conditions below hold:
 *
 * <ol>
 * <li>the property is not defined;
 * <li>the property value cannot be transformed to an int;
 * <li>the property value does not satisfy the checker.
 * </ol>
 */
private static CalciteSystemProperty<Integer> intProperty(String key, int defaultValue,
    IntPredicate valueChecker) {
  return new CalciteSystemProperty<>(key, v -> {
    if (v == null) {
      return defaultValue;
    }
    try {
      int intVal = Integer.parseInt(v);
      return valueChecker.test(intVal) ? intVal : defaultValue;
    } catch (NumberFormatException nfe) {
      return defaultValue;
    }
  });
}
 

@Override
public int lastIndexOf(IntPredicate predicate, int fromIndex) {
	Assert.notNull(predicate, "IntPredicate must not be null");
	int i = Math.min(fromIndex, this.writePosition - 1);
	for (; i >= 0; i--) {
		byte b = this.byteBuffer.get(i);
		if (predicate.test(b)) {
			return i;
		}
	}
	return -1;
}
 

private void checkAndSetOrder(IntPredicate expectedValue,
                              IntUnaryOperator newValue) {
    if (!expectedValue.test(invocationOrder)) {
        throw new TestSupport.AssertionFailedException(
                expectedValue + " -> " + newValue);
    }
    invocationOrder = newValue.applyAsInt(invocationOrder);
}
 

/**
 * Filters an {@link OptionalInt}.
 *
 * @param optional The optional to filter.
 * @param predicate The predicate to filter with.
 * @return The optional if predicate passes, otherwise an empty optional.
 */
public static OptionalInt filter(OptionalInt optional, IntPredicate predicate) {
    if (optional.isPresent()) {
        int value = optional.getAsInt();
        if (predicate.test(value)) {
            return optional;
        }
    }
    return OptionalInt.empty();
}
 

/**
 * Test that each char of specified string match for predicate. <p/>
 * Note that it method does not support unicode, because it usual applicable only for match letters that placed under 128 code.
 * @param str string
 * @param predicate char matcher
 * @return true if all chars match
 */
public static boolean match(String str, IntPredicate predicate) {
    final int len = str.length();
    if(len == 0) {
        return false;
    }
    for(int i = 0; i < len; i++) {
        if(!predicate.test(str.charAt(i))) {
            return false;
        }
    }
    return true;
}
 

@Override
public void trim(IntPredicate aIsTrimChar) {
  int begin = getBegin();
  int end = getEnd();
  String text = _casView.getDocumentText();
    
  // If the span is empty, or there is no text, there is nothing to trim
  if (begin == end || text == null) {
    return;
  }
  
  final int saved_begin = begin;
  final int saved_end = end;
  // First we trim at the end. If a trimmed span is empty, we want to return the original 
  // begin as the begin/end of the trimmed span
  int backwardsSeekingCodepoint;
  while (
            (end > 0)
            && end > begin
            && aIsTrimChar.test(backwardsSeekingCodepoint = text.codePointBefore(end))
  ) {
    end -= Character.charCount(backwardsSeekingCodepoint);
  }
  
  // Then, trim at the start
  int forwardSeekingCodepoint;
  while (
            (begin < (text.length() - 1))
            && begin < end
            && aIsTrimChar.test(forwardSeekingCodepoint = text.codePointAt(begin))
  ) {
    begin += Character.charCount(forwardSeekingCodepoint);
  }
    
  if (saved_begin != begin || saved_end != end) {
    int final_begin = begin;
    int final_end = end;
  
     _casView.protectIndexes(() -> {
        setBegin(final_begin);
        setEnd(final_end);
     });
  }
}
 

/**
 * Creates a new instance of CharTokenizer with the supplied attribute factory using a custom predicate, supplied as method reference or lambda expression.
 * The predicate should return {@code true} for all valid token characters.
 * <p>
 * This factory is intended to be used with lambdas or method references. E.g., an elegant way
 * to create an instance which behaves exactly as {@link LetterTokenizer} is:
 * <pre class="prettyprint lang-java">
 * Tokenizer tok = CharTokenizer.fromTokenCharPredicate(factory, Character::isLetter);
 * </pre>
 */
public static CharTokenizer fromTokenCharPredicate(AttributeFactory factory, final IntPredicate tokenCharPredicate) {
  Objects.requireNonNull(tokenCharPredicate, "predicate must not be null.");
  return new CharTokenizer(factory) {
    @Override
    protected boolean isTokenChar(int c) {
      return tokenCharPredicate.test(c);
    }
  };
}
 

/**
 * Removes elements in an array until the passed function returns true. Returns the remaining elements in the array.
 *
 * @param elements
 * @param condition
 * @return
 */
public static int[] dropElements(int[] elements, IntPredicate condition) {
    while (elements.length > 0 && !condition.test(elements[0])) {
        elements = Arrays.copyOfRange(elements, 1, elements.length);
    }
    return elements;
}
 

/**
 * Check the equality of two intPredicates.
 * Check if the both the predicates either passes together or fails together for each
 * integer in the range [0,noOfTimes]
 *
 * @param firstPredicate  the first IntPredicate.
 * @param secondPredicate the second IntPredicate.
 * @param noOfTimes       Number to check the IntPredicates from.
 * @return whether or not we can say that they are equal.
 */
public static boolean checkEqualityOfIntPredicates(final IntPredicate firstPredicate,
                                                   final IntPredicate secondPredicate, final int noOfTimes) {
  for (int value = 0; value <= noOfTimes; value++) {
    if (firstPredicate.test(value) != secondPredicate.test(value)) {
      return false;
    }
  }
  return true;
}