@Override public int size() { int size = 0; for (E e : unfiltered) { if (predicate.apply(e)) { size++; } } return size; }
@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); } } }
static <K, V> boolean removeAllKeys( Map<K, V> map, Predicate<? super Entry<K, V>> entryPredicate, Collection<?> keyCollection) { Iterator<Entry<K, V>> entryItr = map.entrySet().iterator(); boolean result = false; while (entryItr.hasNext()) { Entry<K, V> entry = entryItr.next(); if (entryPredicate.apply(entry) && keyCollection.contains(entry.getKey())) { entryItr.remove(); result = true; } } return result; }
@Override protected T computeNext() { while (unfiltered.hasNext()) { T element = unfiltered.next(); if (retainIfTrue.apply(element)) { return element; } } return endOfData(); } };
@SuppressWarnings("deprecation") // intentional; deprecation is for callers primarily @Override public boolean apply(Character character) { return predicate.apply(checkNotNull(character)); }
@Override default boolean test(@NullableDecl T input) { return apply(input); } }
@Override public boolean apply(@NullableDecl 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(@NullableDecl 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; }
@Override public boolean apply(Entry<V, K> input) { return forwardPredicate.apply(Maps.immutableEntry(input.getValue(), input.getKey())); } };
@Override public boolean addAll(Collection<? extends E> collection) { for (E element : collection) { checkArgument(predicate.apply(element)); } return unfiltered.addAll(collection); }
@Override public boolean removeIf(java.util.function.Predicate<? super E> filter) { checkNotNull(filter); return unfiltered.removeIf(element -> predicate.apply(element) && filter.test(element)); }
@Override public boolean apply(@NullableDecl T t) { return !predicate.apply(t); }
@Override public boolean add(E element) { checkArgument(predicate.apply(element)); return unfiltered.add(element); }
@Override public int count(@NullableDecl Object element) { int count = unfiltered.count(element); if (count > 0) { @SuppressWarnings("unchecked") // element is equal to an E E e = (E) element; return predicate.apply(e) ? count : 0; } return 0; }
@Override public boolean apply(@NullableDecl A a) { return p.apply(f.apply(a)); }
@Override public boolean contains(@NullableDecl Object element) { if (safeContains(unfiltered, element)) { @SuppressWarnings("unchecked") // element is in unfiltered, so it must be an E E e = (E) element; return predicate.apply(e); } return false; }
@Override public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) { unfiltered() .replaceAll( (key, value) -> predicate.apply(Maps.immutableEntry(key, value)) ? function.apply(key, value) : value); }
@Override public Collection<V> get(K key) { if (keyPredicate.apply(key)) { return unfiltered.get(key); } else if (unfiltered instanceof SetMultimap) { return new AddRejectingSet<>(key); } else { return new AddRejectingList<>(key); } }
boolean apply(@NullableDecl Object key, @NullableDecl 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 int add(@NullableDecl E element, int occurrences) { checkArgument( predicate.apply(element), "Element %s does not match predicate %s", element, predicate); return unfiltered.add(element, occurrences); }