StoreDescriptor sd = copiedStoresListIterator.next(); fam = sd.getFamilyName().toByteArray(); if (famPredicate.apply(fam)) { copiedStoresListIterator.remove(); anyStoreRemoved = true;
@Override public boolean equals(@Nullable Object obj) { if (obj instanceof NotPredicate) { NotPredicate<?> that = (NotPredicate<?>) obj; return predicate.equals(that.predicate); } return false; }
@Override public void forEach(Consumer<? super T> action) { checkNotNull(action); unfiltered.forEach( (T a) -> { if (retainIfTrue.test(a)) { action.accept(a); } }); }
@Override public boolean equals(@Nullable Object obj) { if (obj instanceof PredicateFunction) { PredicateFunction<?> that = (PredicateFunction<?>) obj; return predicate.equals(that.predicate); } return false; }
@Override public void forEach(Consumer<? super E> action) { checkNotNull(action); unfiltered.forEach( (E e) -> { if (predicate.test(e)) { action.accept(e); } }); }
@Override public boolean matches(char c) { return predicate.apply(c); }
@Override public boolean equals(@Nullable Object obj) { if (obj instanceof CompositionPredicate) { CompositionPredicate<?, ?> that = (CompositionPredicate<?, ?>) obj; return f.equals(that.f) && p.equals(that.p); } return false; }
@Override @SuppressWarnings("unchecked") public boolean containsKey(Object key) { return unfiltered.containsKey(key) && keyPredicate.apply((K) key); } }
@Override default boolean test(@Nullable T input) { return apply(input); } }
@Override public boolean apply(@Nullable T t) { return !predicate.apply(t); }
@Override public Boolean apply(@Nullable T t) { return predicate.apply(t); }
@Override public E last() { SortedSet<E> sortedUnfiltered = (SortedSet<E>) unfiltered; while (true) { E element = sortedUnfiltered.last(); if (predicate.apply(element)) { return element; } sortedUnfiltered = sortedUnfiltered.headSet(element); } } }
@Override public boolean apply(@Nullable T t) { // Avoid using the Iterator to avoid generating garbage (issue 820). for (int i = 0; i < components.size(); i++) { if (!components.get(i).apply(t)) { return false; } } return true; }
@Override public boolean apply(@Nullable T t) { // Avoid using the Iterator to avoid generating garbage (issue 820). for (int i = 0; i < components.size(); i++) { if (components.get(i).apply(t)) { return true; } } return false; }
boolean apply(@Nullable Object key, @Nullable V value) { // This method is called only when the key is in the map, implying that // key is a K. @SuppressWarnings("unchecked") K k = (K) key; return predicate.apply(Maps.immutableEntry(k, value)); }
@Override public boolean addAll(Collection<? extends E> collection) { for (E element : collection) { checkArgument(predicate.apply(element)); } return unfiltered.addAll(collection); }
@Override public boolean apply(Entry<V, K> input) { return forwardPredicate.apply(Maps.immutableEntry(input.getValue(), input.getKey())); } };
@Override public boolean removeIf(java.util.function.Predicate<? super E> filter) { checkNotNull(filter); return unfiltered.removeIf(element -> predicate.apply(element) && filter.test(element)); }
@Override protected T computeNext() { while (unfiltered.hasNext()) { T element = unfiltered.next(); if (retainIfTrue.apply(element)) { return element; } } return endOfData(); } };
@Override public boolean containsKey(@Nullable Object key) { if (unfiltered.containsKey(key)) { @SuppressWarnings("unchecked") // k is equal to a K, if not one itself K k = (K) key; return keyPredicate.apply(k); } return false; }