Collector.Characteristics.UNORDERED); @MonotonicNonNull private EnumSet<E> set;
private static class SynchronizedAsMap<K, V> extends SynchronizedMap<K, Collection<V>> { @MonotonicNonNull transient Set<Entry<K, Collection<V>>> asMapEntrySet; @MonotonicNonNull transient Collection<Collection<V>> asMapValues;
private static class SynchronizedSetMultimap<K, V> extends SynchronizedMultimap<K, V> implements SetMultimap<K, V> { @MonotonicNonNull transient Set<Entry<K, V>> entrySet;
static final class MultisetIteratorImpl<E> implements Iterator<E> { private final Multiset<E> multiset; private final Iterator<Entry<E>> entryIterator; @MonotonicNonNull private Entry<E> currentEntry;
private static final long serialVersionUID = 1; transient @MonotonicNonNull LoadingCache<K, V> autoDelegate;
@MonotonicNonNull transient Set<E> elementSet; @MonotonicNonNull transient Set<Multiset.Entry<E>> entrySet;
/** * Abstract set whose {@code isEmpty()} returns whether the table is empty and whose {@code * clear()} clears all table mappings. */ @WeakOuter private abstract class TableSet<T> extends ImprovedAbstractSet<T> { @Override public boolean isEmpty() { return backingMap.isEmpty(); } @Override public void clear() { backingMap.clear(); } }
private static class SynchronizedMultiset<E> extends SynchronizedCollection<E> implements Multiset<E> { @MonotonicNonNull transient Set<E> elementSet; @MonotonicNonNull transient Set<Entry<E>> entrySet;
private transient @MonotonicNonNull UnmodifiableNavigableSet<E> descendingSet;
private transient @MonotonicNonNull Set<Entry<K, V>> entrySet; private transient @MonotonicNonNull Set<K> keySet; private transient @MonotonicNonNull Collection<V> values;
final Map<K, V> unmodifiableMap; final BiMap<? extends K, ? extends V> delegate; @MonotonicNonNull @RetainedWith BiMap<V, K> inverse; @MonotonicNonNull transient Set<V> values;
private abstract class Itr<T> implements Iterator<T> { int expectedModCount = modCount; int currentIndex = firstEntryIndex(); int indexToRemove = -1; @Override public boolean hasNext() { return currentIndex >= 0; } abstract T getOutput(int entry); @Override public T next() { checkForConcurrentModification(); if (!hasNext()) { throw new NoSuchElementException(); } indexToRemove = currentIndex; T result = getOutput(currentIndex); currentIndex = getSuccessor(currentIndex); return result; } @Override public void remove() { checkForConcurrentModification(); checkRemove(indexToRemove >= 0); expectedModCount++; removeEntry(indexToRemove);
static final NaturalOrdering INSTANCE = new NaturalOrdering(); private transient @MonotonicNonNull Ordering<Comparable> nullsFirst; private transient @MonotonicNonNull Ordering<Comparable> nullsLast;
@VisibleForTesting static class SynchronizedBiMap<K, V> extends SynchronizedMap<K, V> implements BiMap<K, V>, Serializable { private transient @MonotonicNonNull Set<V> valueSet; @MonotonicNonNull @RetainedWith private transient BiMap<V, K> inverse;
private abstract class Itr<T> implements Iterator<T> { final Iterator<Entry<K, Collection<V>>> keyIterator; @Nullable K key; @MonotonicNonNull Collection<V> collection; Iterator<V> valueIterator;
final class WellBehavedMap<K, V> extends ForwardingMap<K, V> { private final Map<K, V> delegate; @MonotonicNonNull private Set<Entry<K, V>> entrySet;
private transient @MonotonicNonNull UnmodifiableSortedMultiset<E> descendingMultiset;
@Override public UnmodifiableIterator<E> iterator() { final Iterator<Entry<E>> entryIterator = entrySet().iterator(); return new UnmodifiableIterator<E>() { int remaining; @MonotonicNonNull E element; @Override public boolean hasNext() { return (remaining > 0) || entryIterator.hasNext(); } @Override public E next() { if (remaining <= 0) { Entry<E> entry = entryIterator.next(); element = entry.getElement(); remaining = entry.getCount(); } remaining--; return element; } }; }
abstract class Itr<T> implements Iterator<T> { BiEntry<K, V> next = firstInKeyInsertionOrder; BiEntry<K, V> toRemove = null; int expectedModCount = modCount; int remaining = size(); @Override public boolean hasNext() { if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } return next != null && remaining > 0; } @Override public T next() { if (!hasNext()) { throw new NoSuchElementException(); } BiEntry<K, V> entry = next; next = entry.nextInKeyInsertionOrder; toRemove = entry; remaining--; return output(entry); } @Override public void remove() { if (modCount != expectedModCount) {
abstract class AbstractCacheSet<T> extends AbstractSet<T> { @Weak final ConcurrentMap<?, ?> map; AbstractCacheSet(ConcurrentMap<?, ?> map) { this.map = map; } @Override public int size() { return map.size(); } @Override public boolean isEmpty() { return map.isEmpty(); } @Override public void clear() { map.clear(); } // super.toArray() may misbehave if size() is inaccurate, at least on old versions of Android. // https://code.google.com/p/android/issues/detail?id=36519 / http://r.android.com/47508 @Override public Object[] toArray() { return toArrayList(this).toArray(); } @Override public <E> E[] toArray(E[] a) { return toArrayList(this).toArray(a); } }