Object readResolve() { return map.entrySet(); }
private abstract class Itr<T> extends UnmodifiableIterator<T> { final Iterator<Entry<K, Collection<V>>> mapIterator = asMap().entrySet().iterator(); K key = null; Iterator<V> valueIterator = Iterators.emptyIterator(); abstract T output(K key, V value); @Override public boolean hasNext() { return mapIterator.hasNext() || valueIterator.hasNext(); } @Override public T next() { if (!valueIterator.hasNext()) { Entry<K, Collection<V>> mapEntry = mapIterator.next(); key = mapEntry.getKey(); valueIterator = mapEntry.getValue().iterator(); } return output(key, valueIterator.next()); } }
@Override public int hashCode() { return Sets.hashCodeImpl(entrySet()); }
UnmodifiableIterator<K> keyIterator() { final UnmodifiableIterator<Entry<K, V>> entryIterator = entrySet().iterator(); return new UnmodifiableIterator<K>() { @Override public boolean hasNext() { return entryIterator.hasNext(); } @Override public K next() { return entryIterator.next().getKey(); } }; }
@Override public UnmodifiableIterator<V> iterator() { return new UnmodifiableIterator<V>() { final UnmodifiableIterator<Entry<K, V>> entryItr = map.entrySet().iterator(); @Override public boolean hasNext() { return entryItr.hasNext(); } @Override public V next() { return entryItr.next().getValue(); } }; }
@Override public ImmutableList<V> asList() { final ImmutableList<Entry<K, V>> entryList = map.entrySet().asList(); return new ImmutableAsList<V>() { @Override public V get(int index) { return entryList.get(index).getValue(); } @Override ImmutableCollection<V> delegateCollection() { return ImmutableMapValues.this; } }; }
public final void scan(ClassLoader classloader) throws IOException { for (Map.Entry<File, ClassLoader> entry : getClassPathEntries(classloader).entrySet()) { scan(entry.getKey(), entry.getValue()); } }
SerializedForm(ImmutableMap<?, ?> map) { keys = new Object[map.size()]; values = new Object[map.size()]; int i = 0; for (Entry<?, ?> entry : map.entrySet()) { keys[i] = entry.getKey(); values[i] = entry.getValue(); i++; } }
@Override Cell<R, C, V> getCell(int index) { int rowIndex = cellRowIndices[index]; Map.Entry<R, Map<C, V>> rowEntry = rowMap.entrySet().asList().get(rowIndex); ImmutableMap<C, V> row = (ImmutableMap<C, V>) rowEntry.getValue(); int columnIndex = cellColumnInRowIndices[index]; Map.Entry<C, V> colEntry = row.entrySet().asList().get(columnIndex); return cellOf(rowEntry.getKey(), colEntry.getKey(), colEntry.getValue()); }
@Override K get(int index) { return map.entrySet().asList().get(index).getKey(); }
Object createRangeMap() { Builder<K, V> builder = new Builder<K, V>(); for (Entry<Range<K>, V> entry : mapOfRanges.entrySet()) { builder.put(entry.getKey(), entry.getValue()); } return builder.build(); }
Spliterator<K> keySpliterator() { return CollectSpliterators.map(entrySet().spliterator(), Entry::getKey); }
@Override public Spliterator<V> spliterator() { return CollectSpliterators.map(map.entrySet().spliterator(), Entry::getValue); }
try { ImmutableRangeMap<Long, BlockLocation> rangeMap = getBlockMap(status); for (Entry<Range<Long>, BlockLocation> l : rangeMap.asMapOfRanges().entrySet()) { work.add(new CompleteFileWork(getEndpointByteMap(noDrillbitHosts, new FileStatusWork(status)), l.getValue().getOffset(), l.getValue().getLength(), status.getPath() .toString()));
@Override Spliterator<Entry<K, V>> entrySpliterator() { return CollectSpliterators.flatMap( asMap().entrySet().spliterator(), keyToValueCollectionEntry -> { K key = keyToValueCollectionEntry.getKey(); Collection<V> valueCollection = keyToValueCollectionEntry.getValue(); return CollectSpliterators.map( valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value)); }, Spliterator.SIZED | (this instanceof SetMultimap ? Spliterator.DISTINCT : 0), size()); }
for (Map.Entry<Range<Long>,BlockLocation> block : subRangeMap.asMapOfRanges().entrySet()) { String[] hosts; Range<Long> blockRange = block.getKey();