Source code

001/*
002 * Copyright (C) 2008 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.collect;
018
019import static com.google.common.base.Preconditions.checkNotNull;
020import static com.google.common.collect.CollectPreconditions.checkEntryNotNull;
021import static com.google.common.collect.Maps.immutableEntry;
022import static java.util.Objects.requireNonNull;
023
024import com.google.common.annotations.Beta;
025import com.google.common.annotations.GwtCompatible;
026import com.google.common.annotations.GwtIncompatible;
027import com.google.errorprone.annotations.CanIgnoreReturnValue;
028import com.google.errorprone.annotations.DoNotCall;
029import com.google.errorprone.annotations.DoNotMock;
030import com.google.j2objc.annotations.Weak;
031import com.google.j2objc.annotations.WeakOuter;
032import java.io.Serializable;
033import java.util.ArrayList;
034import java.util.Arrays;
035import java.util.Collection;
036import java.util.Comparator;
037import java.util.Iterator;
038import java.util.Map;
039import java.util.Map.Entry;
040import java.util.Set;
041import java.util.Spliterator;
042import java.util.function.BiConsumer;
043import javax.annotation.CheckForNull;
044import org.checkerframework.checker.nullness.qual.Nullable;
045
046/**
047 * A {@link Multimap} whose contents will never change, with many other important properties
048 * detailed at {@link ImmutableCollection}.
049 *
050 * <p><b>Warning:</b> avoid <i>direct</i> usage of {@link ImmutableMultimap} as a type (as with
051 * {@link Multimap} itself). Prefer subtypes such as {@link ImmutableSetMultimap} or {@link
052 * ImmutableListMultimap}, which have well-defined {@link #equals} semantics, thus avoiding a common
053 * source of bugs and confusion.
054 *
055 * <p><b>Note:</b> every {@link ImmutableMultimap} offers an {@link #inverse} view, so there is no
056 * need for a distinct {@code ImmutableBiMultimap} type.
057 *
058 * <p><a id="iteration"></a>
059 *
060 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
061 * current implementations, the iteration order always keeps multiple entries with the same key
062 * together. Any creation method that would customarily respect insertion order (such as {@link
063 * #copyOf(Multimap)}) instead preserves key-grouped order by inserting entries for an existing key
064 * immediately after the last entry having that key.
065 *
066 * <p>See the Guava User Guide article on <a href=
067 * "https://github.com/google/guava/wiki/ImmutableCollectionsExplained">immutable collections</a>.
068 *
069 * @author Jared Levy
070 * @since 2.0
071 */
072@GwtCompatible(emulated = true)
073@ElementTypesAreNonnullByDefault
074public abstract class ImmutableMultimap<K, V> extends BaseImmutableMultimap<K, V>
075    implements Serializable {
076
077  /**
078   * Returns an empty multimap.
079   *
080   * <p><b>Performance note:</b> the instance returned is a singleton.
081   */
082  public static <K, V> ImmutableMultimap<K, V> of() {
083    return ImmutableListMultimap.of();
084  }
085
086  /** Returns an immutable multimap containing a single entry. */
087  public static <K, V> ImmutableMultimap<K, V> of(K k1, V v1) {
088    return ImmutableListMultimap.of(k1, v1);
089  }
090
091  /** Returns an immutable multimap containing the given entries, in order. */
092  public static <K, V> ImmutableMultimap<K, V> of(K k1, V v1, K k2, V v2) {
093    return ImmutableListMultimap.of(k1, v1, k2, v2);
094  }
095
096  /**
097   * Returns an immutable multimap containing the given entries, in the "key-grouped" insertion
098   * order described in the <a href="#iteration">class documentation</a>.
099   */
100  public static <K, V> ImmutableMultimap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
101    return ImmutableListMultimap.of(k1, v1, k2, v2, k3, v3);
102  }
103
104  /**
105   * Returns an immutable multimap containing the given entries, in the "key-grouped" insertion
106   * order described in the <a href="#iteration">class documentation</a>.
107   */
108  public static <K, V> ImmutableMultimap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
109    return ImmutableListMultimap.of(k1, v1, k2, v2, k3, v3, k4, v4);
110  }
111
112  /**
113   * Returns an immutable multimap containing the given entries, in the "key-grouped" insertion
114   * order described in the <a href="#iteration">class documentation</a>.
115   */
116  public static <K, V> ImmutableMultimap<K, V> of(
117      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
118    return ImmutableListMultimap.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
119  }
120
121  // looking for of() with > 5 entries? Use the builder instead.
122
123  /**
124   * Returns a new builder. The generated builder is equivalent to the builder created by the {@link
125   * Builder} constructor.
126   */
127  public static <K, V> Builder<K, V> builder() {
128    return new Builder<>();
129  }
130
131  /**
132   * A builder for creating immutable multimap instances, especially {@code public static final}
133   * multimaps ("constant multimaps"). Example:
134   *
135   * <pre>{@code
136   * static final Multimap<String, Integer> STRING_TO_INTEGER_MULTIMAP =
137   *     new ImmutableMultimap.Builder<String, Integer>()
138   *         .put("one", 1)
139   *         .putAll("several", 1, 2, 3)
140   *         .putAll("many", 1, 2, 3, 4, 5)
141   *         .build();
142   * }</pre>
143   *
144   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
145   * multiple multimaps in series. Each multimap contains the key-value mappings in the previously
146   * created multimaps.
147   *
148   * @since 2.0
149   */
150  @DoNotMock
151  public static class Builder<K, V> {
152    final Map<K, Collection<V>> builderMap;
153    @CheckForNull Comparator<? super K> keyComparator;
154    @CheckForNull Comparator<? super V> valueComparator;
155
156    /**
157     * Creates a new builder. The returned builder is equivalent to the builder generated by {@link
158     * ImmutableMultimap#builder}.
159     */
160    public Builder() {
161      this.builderMap = Platform.preservesInsertionOrderOnPutsMap();
162    }
163
164    Collection<V> newMutableValueCollection() {
165      return new ArrayList<>();
166    }
167
168    /** Adds a key-value mapping to the built multimap. */
169    @CanIgnoreReturnValue
170    public Builder<K, V> put(K key, V value) {
171      checkEntryNotNull(key, value);
172      Collection<V> valueCollection = builderMap.get(key);
173      if (valueCollection == null) {
174        builderMap.put(key, valueCollection = newMutableValueCollection());
175      }
176      valueCollection.add(value);
177      return this;
178    }
179
180    /**
181     * Adds an entry to the built multimap.
182     *
183     * @since 11.0
184     */
185    @CanIgnoreReturnValue
186    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
187      return put(entry.getKey(), entry.getValue());
188    }
189
190    /**
191     * Adds entries to the built multimap.
192     *
193     * @since 19.0
194     */
195    @CanIgnoreReturnValue
196    @Beta
197    public Builder<K, V> putAll(Iterable<? extends Entry<? extends K, ? extends V>> entries) {
198      for (Entry<? extends K, ? extends V> entry : entries) {
199        put(entry);
200      }
201      return this;
202    }
203
204    /**
205     * Stores a collection of values with the same key in the built multimap.
206     *
207     * @throws NullPointerException if {@code key}, {@code values}, or any element in {@code values}
208     *     is null. The builder is left in an invalid state.
209     */
210    @CanIgnoreReturnValue
211    public Builder<K, V> putAll(K key, Iterable<? extends V> values) {
212      if (key == null) {
213        throw new NullPointerException("null key in entry: null=" + Iterables.toString(values));
214      }
215      Collection<V> valueCollection = builderMap.get(key);
216      if (valueCollection != null) {
217        for (V value : values) {
218          checkEntryNotNull(key, value);
219          valueCollection.add(value);
220        }
221        return this;
222      }
223      Iterator<? extends V> valuesItr = values.iterator();
224      if (!valuesItr.hasNext()) {
225        return this;
226      }
227      valueCollection = newMutableValueCollection();
228      while (valuesItr.hasNext()) {
229        V value = valuesItr.next();
230        checkEntryNotNull(key, value);
231        valueCollection.add(value);
232      }
233      builderMap.put(key, valueCollection);
234      return this;
235    }
236
237    /**
238     * Stores an array of values with the same key in the built multimap.
239     *
240     * @throws NullPointerException if the key or any value is null. The builder is left in an
241     *     invalid state.
242     */
243    @CanIgnoreReturnValue
244    public Builder<K, V> putAll(K key, V... values) {
245      return putAll(key, Arrays.asList(values));
246    }
247
248    /**
249     * Stores another multimap's entries in the built multimap. The generated multimap's key and
250     * value orderings correspond to the iteration ordering of the {@code multimap.asMap()} view,
251     * with new keys and values following any existing keys and values.
252     *
253     * @throws NullPointerException if any key or value in {@code multimap} is null. The builder is
254     *     left in an invalid state.
255     */
256    @CanIgnoreReturnValue
257    public Builder<K, V> putAll(Multimap<? extends K, ? extends V> multimap) {
258      for (Entry<? extends K, ? extends Collection<? extends V>> entry :
259          multimap.asMap().entrySet()) {
260        putAll(entry.getKey(), entry.getValue());
261      }
262      return this;
263    }
264
265    /**
266     * Specifies the ordering of the generated multimap's keys.
267     *
268     * @since 8.0
269     */
270    @CanIgnoreReturnValue
271    public Builder<K, V> orderKeysBy(Comparator<? super K> keyComparator) {
272      this.keyComparator = checkNotNull(keyComparator);
273      return this;
274    }
275
276    /**
277     * Specifies the ordering of the generated multimap's values for each key.
278     *
279     * @since 8.0
280     */
281    @CanIgnoreReturnValue
282    public Builder<K, V> orderValuesBy(Comparator<? super V> valueComparator) {
283      this.valueComparator = checkNotNull(valueComparator);
284      return this;
285    }
286
287    @CanIgnoreReturnValue
288    Builder<K, V> combine(Builder<K, V> other) {
289      for (Map.Entry<K, Collection<V>> entry : other.builderMap.entrySet()) {
290        putAll(entry.getKey(), entry.getValue());
291      }
292      return this;
293    }
294
295    /** Returns a newly-created immutable multimap. */
296    public ImmutableMultimap<K, V> build() {
297      Collection<Map.Entry<K, Collection<V>>> mapEntries = builderMap.entrySet();
298      if (keyComparator != null) {
299        mapEntries = Ordering.from(keyComparator).<K>onKeys().immutableSortedCopy(mapEntries);
300      }
301      return ImmutableListMultimap.fromMapEntries(mapEntries, valueComparator);
302    }
303  }
304
305  /**
306   * Returns an immutable multimap containing the same mappings as {@code multimap}, in the
307   * "key-grouped" iteration order described in the class documentation.
308   *
309   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
310   * safe to do so. The exact circumstances under which a copy will or will not be performed are
311   * undocumented and subject to change.
312   *
313   * @throws NullPointerException if any key or value in {@code multimap} is null
314   */
315  public static <K, V> ImmutableMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> multimap) {
316    if (multimap instanceof ImmutableMultimap) {
317      @SuppressWarnings("unchecked") // safe since multimap is not writable
318      ImmutableMultimap<K, V> kvMultimap = (ImmutableMultimap<K, V>) multimap;
319      if (!kvMultimap.isPartialView()) {
320        return kvMultimap;
321      }
322    }
323    return ImmutableListMultimap.copyOf(multimap);
324  }
325
326  /**
327   * Returns an immutable multimap containing the specified entries. The returned multimap iterates
328   * over keys in the order they were first encountered in the input, and the values for each key
329   * are iterated in the order they were encountered.
330   *
331   * @throws NullPointerException if any key, value, or entry is null
332   * @since 19.0
333   */
334  @Beta
335  public static <K, V> ImmutableMultimap<K, V> copyOf(
336      Iterable<? extends Entry<? extends K, ? extends V>> entries) {
337    return ImmutableListMultimap.copyOf(entries);
338  }
339
340  final transient ImmutableMap<K, ? extends ImmutableCollection<V>> map;
341  final transient int size;
342
343  // These constants allow the deserialization code to set final fields. This
344  // holder class makes sure they are not initialized unless an instance is
345  // deserialized.
346  @GwtIncompatible // java serialization is not supported
347  static class FieldSettersHolder {
348    static final Serialization.FieldSetter<ImmutableMultimap> MAP_FIELD_SETTER =
349        Serialization.getFieldSetter(ImmutableMultimap.class, "map");
350    static final Serialization.FieldSetter<ImmutableMultimap> SIZE_FIELD_SETTER =
351        Serialization.getFieldSetter(ImmutableMultimap.class, "size");
352  }
353
354  ImmutableMultimap(ImmutableMap<K, ? extends ImmutableCollection<V>> map, int size) {
355    this.map = map;
356    this.size = size;
357  }
358
359  // mutators (not supported)
360
361  /**
362   * Guaranteed to throw an exception and leave the multimap unmodified.
363   *
364   * @throws UnsupportedOperationException always
365   * @deprecated Unsupported operation.
366   */
367  @CanIgnoreReturnValue
368  @Deprecated
369  @Override
370  @DoNotCall("Always throws UnsupportedOperationException")
371  // DoNotCall wants this to be final, but we want to override it to return more specific types.
372  // Inheritance is closed, and all subtypes are @DoNotCall, so this is safe to suppress.
373  @SuppressWarnings("DoNotCall")
374  public ImmutableCollection<V> removeAll(@CheckForNull Object key) {
375    throw new UnsupportedOperationException();
376  }
377
378  /**
379   * Guaranteed to throw an exception and leave the multimap unmodified.
380   *
381   * @throws UnsupportedOperationException always
382   * @deprecated Unsupported operation.
383   */
384  @CanIgnoreReturnValue
385  @Deprecated
386  @Override
387  @DoNotCall("Always throws UnsupportedOperationException")
388  // DoNotCall wants this to be final, but we want to override it to return more specific types.
389  // Inheritance is closed, and all subtypes are @DoNotCall, so this is safe to suppress.
390  @SuppressWarnings("DoNotCall")
391  public ImmutableCollection<V> replaceValues(K key, Iterable<? extends V> values) {
392    throw new UnsupportedOperationException();
393  }
394
395  /**
396   * Guaranteed to throw an exception and leave the multimap unmodified.
397   *
398   * @throws UnsupportedOperationException always
399   * @deprecated Unsupported operation.
400   */
401  @Deprecated
402  @Override
403  @DoNotCall("Always throws UnsupportedOperationException")
404  public final void clear() {
405    throw new UnsupportedOperationException();
406  }
407
408  /**
409   * Returns an immutable collection of the values for the given key. If no mappings in the multimap
410   * have the provided key, an empty immutable collection is returned. The values are in the same
411   * order as the parameters used to build this multimap.
412   */
413  @Override
414  public abstract ImmutableCollection<V> get(K key);
415
416  /**
417   * Returns an immutable multimap which is the inverse of this one. For every key-value mapping in
418   * the original, the result will have a mapping with key and value reversed.
419   *
420   * @since 11.0
421   */
422  public abstract ImmutableMultimap<V, K> inverse();
423
424  /**
425   * Guaranteed to throw an exception and leave the multimap unmodified.
426   *
427   * @throws UnsupportedOperationException always
428   * @deprecated Unsupported operation.
429   */
430  @CanIgnoreReturnValue
431  @Deprecated
432  @Override
433  @DoNotCall("Always throws UnsupportedOperationException")
434  public final boolean put(K key, V value) {
435    throw new UnsupportedOperationException();
436  }
437
438  /**
439   * Guaranteed to throw an exception and leave the multimap unmodified.
440   *
441   * @throws UnsupportedOperationException always
442   * @deprecated Unsupported operation.
443   */
444  @CanIgnoreReturnValue
445  @Deprecated
446  @Override
447  @DoNotCall("Always throws UnsupportedOperationException")
448  public final boolean putAll(K key, Iterable<? extends V> values) {
449    throw new UnsupportedOperationException();
450  }
451
452  /**
453   * Guaranteed to throw an exception and leave the multimap unmodified.
454   *
455   * @throws UnsupportedOperationException always
456   * @deprecated Unsupported operation.
457   */
458  @CanIgnoreReturnValue
459  @Deprecated
460  @Override
461  @DoNotCall("Always throws UnsupportedOperationException")
462  public final boolean putAll(Multimap<? extends K, ? extends V> multimap) {
463    throw new UnsupportedOperationException();
464  }
465
466  /**
467   * Guaranteed to throw an exception and leave the multimap unmodified.
468   *
469   * @throws UnsupportedOperationException always
470   * @deprecated Unsupported operation.
471   */
472  @CanIgnoreReturnValue
473  @Deprecated
474  @Override
475  @DoNotCall("Always throws UnsupportedOperationException")
476  public final boolean remove(@CheckForNull Object key, @CheckForNull Object value) {
477    throw new UnsupportedOperationException();
478  }
479
480  /**
481   * Returns {@code true} if this immutable multimap's implementation contains references to
482   * user-created objects that aren't accessible via this multimap's methods. This is generally used
483   * to determine whether {@code copyOf} implementations should make an explicit copy to avoid
484   * memory leaks.
485   */
486  boolean isPartialView() {
487    return map.isPartialView();
488  }
489
490  // accessors
491
492  @Override
493  public boolean containsKey(@CheckForNull Object key) {
494    return map.containsKey(key);
495  }
496
497  @Override
498  public boolean containsValue(@CheckForNull Object value) {
499    return value != null && super.containsValue(value);
500  }
501
502  @Override
503  public int size() {
504    return size;
505  }
506
507  // views
508
509  /**
510   * Returns an immutable set of the distinct keys in this multimap, in the same order as they
511   * appear in this multimap.
512   */
513  @Override
514  public ImmutableSet<K> keySet() {
515    return map.keySet();
516  }
517
518  @Override
519  Set<K> createKeySet() {
520    throw new AssertionError("unreachable");
521  }
522
523  /**
524   * Returns an immutable map that associates each key with its corresponding values in the
525   * multimap. Keys and values appear in the same order as in this multimap.
526   */
527  @Override
528  @SuppressWarnings("unchecked") // a widening cast
529  public ImmutableMap<K, Collection<V>> asMap() {
530    return (ImmutableMap) map;
531  }
532
533  @Override
534  Map<K, Collection<V>> createAsMap() {
535    throw new AssertionError("should never be called");
536  }
537
538  /** Returns an immutable collection of all key-value pairs in the multimap. */
539  @Override
540  public ImmutableCollection<Entry<K, V>> entries() {
541    return (ImmutableCollection<Entry<K, V>>) super.entries();
542  }
543
544  @Override
545  ImmutableCollection<Entry<K, V>> createEntries() {
546    return new EntryCollection<>(this);
547  }
548
549  private static class EntryCollection<K, V> extends ImmutableCollection<Entry<K, V>> {
550    @Weak final ImmutableMultimap<K, V> multimap;
551
552    EntryCollection(ImmutableMultimap<K, V> multimap) {
553      this.multimap = multimap;
554    }
555
556    @Override
557    public UnmodifiableIterator<Entry<K, V>> iterator() {
558      return multimap.entryIterator();
559    }
560
561    @Override
562    boolean isPartialView() {
563      return multimap.isPartialView();
564    }
565
566    @Override
567    public int size() {
568      return multimap.size();
569    }
570
571    @Override
572    public boolean contains(@CheckForNull Object object) {
573      if (object instanceof Entry) {
574        Entry<?, ?> entry = (Entry<?, ?>) object;
575        return multimap.containsEntry(entry.getKey(), entry.getValue());
576      }
577      return false;
578    }
579
580    private static final long serialVersionUID = 0;
581  }
582
583  @Override
584  UnmodifiableIterator<Entry<K, V>> entryIterator() {
585    return new UnmodifiableIterator<Entry<K, V>>() {
586      final Iterator<? extends Entry<K, ? extends ImmutableCollection<V>>> asMapItr =
587          map.entrySet().iterator();
588      @CheckForNull K currentKey = null;
589      Iterator<V> valueItr = Iterators.emptyIterator();
590
591      @Override
592      public boolean hasNext() {
593        return valueItr.hasNext() || asMapItr.hasNext();
594      }
595
596      @Override
597      public Entry<K, V> next() {
598        if (!valueItr.hasNext()) {
599          Entry<K, ? extends ImmutableCollection<V>> entry = asMapItr.next();
600          currentKey = entry.getKey();
601          valueItr = entry.getValue().iterator();
602        }
603        /*
604         * requireNonNull is safe: The first call to this method always enters the !hasNext() case
605         * and populates currentKey, after which it's never cleared.
606         */
607        return immutableEntry(requireNonNull(currentKey), valueItr.next());
608      }
609    };
610  }
611
612  @Override
613  Spliterator<Entry<K, V>> entrySpliterator() {
614    return CollectSpliterators.flatMap(
615        asMap().entrySet().spliterator(),
616        keyToValueCollectionEntry -> {
617          K key = keyToValueCollectionEntry.getKey();
618          Collection<V> valueCollection = keyToValueCollectionEntry.getValue();
619          return CollectSpliterators.map(
620              valueCollection.spliterator(), (V value) -> Maps.immutableEntry(key, value));
621        },
622        Spliterator.SIZED | (this instanceof SetMultimap ? Spliterator.DISTINCT : 0),
623        size());
624  }
625
626  @Override
627  public void forEach(BiConsumer<? super K, ? super V> action) {
628    checkNotNull(action);
629    asMap()
630        .forEach(
631            (key, valueCollection) -> valueCollection.forEach(value -> action.accept(key, value)));
632  }
633
634  /**
635   * Returns an immutable multiset containing all the keys in this multimap, in the same order and
636   * with the same frequencies as they appear in this multimap; to get only a single occurrence of
637   * each key, use {@link #keySet}.
638   */
639  @Override
640  public ImmutableMultiset<K> keys() {
641    return (ImmutableMultiset<K>) super.keys();
642  }
643
644  @Override
645  ImmutableMultiset<K> createKeys() {
646    return new Keys();
647  }
648
649  @SuppressWarnings("serial") // Uses writeReplace, not default serialization
650  @WeakOuter
651  class Keys extends ImmutableMultiset<K> {
652    @Override
653    public boolean contains(@CheckForNull Object object) {
654      return containsKey(object);
655    }
656
657    @Override
658    public int count(@CheckForNull Object element) {
659      Collection<V> values = map.get(element);
660      return (values == null) ? 0 : values.size();
661    }
662
663    @Override
664    public ImmutableSet<K> elementSet() {
665      return keySet();
666    }
667
668    @Override
669    public int size() {
670      return ImmutableMultimap.this.size();
671    }
672
673    @Override
674    Multiset.Entry<K> getEntry(int index) {
675      Map.Entry<K, ? extends Collection<V>> entry = map.entrySet().asList().get(index);
676      return Multisets.immutableEntry(entry.getKey(), entry.getValue().size());
677    }
678
679    @Override
680    boolean isPartialView() {
681      return true;
682    }
683
684    @GwtIncompatible
685    @Override
686    Object writeReplace() {
687      return new KeysSerializedForm(ImmutableMultimap.this);
688    }
689  }
690
691  @GwtIncompatible
692  private static final class KeysSerializedForm implements Serializable {
693    final ImmutableMultimap<?, ?> multimap;
694
695    KeysSerializedForm(ImmutableMultimap<?, ?> multimap) {
696      this.multimap = multimap;
697    }
698
699    Object readResolve() {
700      return multimap.keys();
701    }
702  }
703
704  /**
705   * Returns an immutable collection of the values in this multimap. Its iterator traverses the
706   * values for the first key, the values for the second key, and so on.
707   */
708  @Override
709  public ImmutableCollection<V> values() {
710    return (ImmutableCollection<V>) super.values();
711  }
712
713  @Override
714  ImmutableCollection<V> createValues() {
715    return new Values<>(this);
716  }
717
718  @Override
719  UnmodifiableIterator<V> valueIterator() {
720    return new UnmodifiableIterator<V>() {
721      Iterator<? extends ImmutableCollection<V>> valueCollectionItr = map.values().iterator();
722      Iterator<V> valueItr = Iterators.emptyIterator();
723
724      @Override
725      public boolean hasNext() {
726        return valueItr.hasNext() || valueCollectionItr.hasNext();
727      }
728
729      @Override
730      public V next() {
731        if (!valueItr.hasNext()) {
732          valueItr = valueCollectionItr.next().iterator();
733        }
734        return valueItr.next();
735      }
736    };
737  }
738
739  private static final class Values<K, V> extends ImmutableCollection<V> {
740    @Weak private final transient ImmutableMultimap<K, V> multimap;
741
742    Values(ImmutableMultimap<K, V> multimap) {
743      this.multimap = multimap;
744    }
745
746    @Override
747    public boolean contains(@CheckForNull Object object) {
748      return multimap.containsValue(object);
749    }
750
751    @Override
752    public UnmodifiableIterator<V> iterator() {
753      return multimap.valueIterator();
754    }
755
756    @GwtIncompatible // not present in emulated superclass
757    @Override
758    int copyIntoArray(@Nullable Object[] dst, int offset) {
759      for (ImmutableCollection<V> valueCollection : multimap.map.values()) {
760        offset = valueCollection.copyIntoArray(dst, offset);
761      }
762      return offset;
763    }
764
765    @Override
766    public int size() {
767      return multimap.size();
768    }
769
770    @Override
771    boolean isPartialView() {
772      return true;
773    }
774
775    private static final long serialVersionUID = 0;
776  }
777
778  private static final long serialVersionUID = 0;
779}