/*
 * Copyright (C) 2007 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.glassfish.jersey.internal.guava;

import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;

import static org.glassfish.jersey.internal.guava.Preconditions.checkArgument;
import static org.glassfish.jersey.internal.guava.Preconditions.checkNotNull;

Basic implementation of the Multimap interface. This class represents a multimap as a map that associates each key with a collection of values. All methods of Multimap are supported, including those specified as optional in the interface. 

To implement a multimap, a subclass must define the method createCollection(), which creates an empty collection of values for a key. 

The multimap constructor takes a map that has a single entry for each distinct key. When you insert a key-value pair with a key that isn't already in the multimap, AbstractMapBasedMultimap calls createCollection() to create the collection of values for that key. The subclass should not call createCollection() directly, and a new instance should be created every time the method is called. 

For example, the subclass could pass a TreeMap during construction, and createCollection() could return a TreeSet, in which case the multimap's iterators would propagate through the keys and values in sorted order. 

Keys and values may be null, as long as the underlying collection classes
support null elements.

The collections created by createCollection() may or may not allow duplicates. If the collection, such as a Set, does not support duplicates, an added key-value pair will replace an existing pair with the same key and value, if such a pair is present. With collections like List that allow duplicates, the collection will keep the existing key-value pairs while adding a new pair. 

This class is not threadsafe when any concurrent operations update the multimap, even if the underlying map and createCollection() method return threadsafe classes. Concurrent read operations will work correctly. To allow concurrent update operations, wrap your multimap with a call to Multimaps.synchronizedMultimap. 

For serialization to work, the subclass must specify explicit readObject and writeObject methods. 
Author:
Jared Levy, Louis Wasserman/**
 * Basic implementation of the {@link Multimap} interface. This class represents
 * a multimap as a map that associates each key with a collection of values. All
 * methods of {@link Multimap} are supported, including those specified as
 * optional in the interface.
 * <p>
 * <p>To implement a multimap, a subclass must define the method {@link
 * #createCollection()}, which creates an empty collection of values for a key.
 * <p>
 * <p>The multimap constructor takes a map that has a single entry for each
 * distinct key. When you insert a key-value pair with a key that isn't already
 * in the multimap, {@code AbstractMapBasedMultimap} calls {@link #createCollection()}
 * to create the collection of values for that key. The subclass should not call
 * {@link #createCollection()} directly, and a new instance should be created
 * every time the method is called.
 * <p>
 * <p>For example, the subclass could pass a {@link java.util.TreeMap} during
 * construction, and {@link #createCollection()} could return a {@link
 * java.util.TreeSet}, in which case the multimap's iterators would propagate
 * through the keys and values in sorted order.
 * <p>
 * <p>Keys and values may be null, as long as the underlying collection classes
 * support null elements.
 * <p>
 * <p>The collections created by {@link #createCollection()} may or may not
 * allow duplicates. If the collection, such as a {@link Set}, does not support
 * duplicates, an added key-value pair will replace an existing pair with the
 * same key and value, if such a pair is present. With collections like {@link
 * List} that allow duplicates, the collection will keep the existing key-value
 * pairs while adding a new pair.
 * <p>
 * <p>This class is not threadsafe when any concurrent operations update the
 * multimap, even if the underlying map and {@link #createCollection()} method
 * return threadsafe classes. Concurrent read operations will work correctly. To
 * allow concurrent update operations, wrap your multimap with a call to {@link
 * Multimaps#synchronizedMultimap}.
 * <p>
 * <p>For serialization to work, the subclass must specify explicit
 * {@code readObject} and {@code writeObject} methods.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
abstract class AbstractMapBasedMultimap<K, V> extends AbstractMultimap<K, V>
        implements Serializable {
  /*
   * Here's an outline of the overall design.
   *
   * The map variable contains the collection of values associated with each
   * key. When a key-value pair is added to a multimap that didn't previously
   * contain any values for that key, a new collection generated by
   * createCollection is added to the map. That same collection instance
   * remains in the map as long as the multimap has any values for the key. If
   * all values for the key are removed, the key and collection are removed
   * from the map.
   *
   * The get method returns a WrappedCollection, which decorates the collection
   * in the map (if the key is present) or an empty collection (if the key is
   * not present). When the collection delegate in the WrappedCollection is
   * empty, the multimap may contain subsequently added values for that key. To
   * handle that situation, the WrappedCollection checks whether map contains
   * an entry for the provided key, and if so replaces the delegate.
   */

    private static final long serialVersionUID = 2447537837011683357L;
    private transient Map<K, Collection<V>> map;
    private transient int totalSize;

    
Creates a new multimap that uses the provided map.
Params:
map – place to store the mapping from each key to its corresponding
           values
Throws:
IllegalArgumentException – if map is not empty/**
     * Creates a new multimap that uses the provided map.
     *
     * @param map place to store the mapping from each key to its corresponding
     *            values
     * @throws IllegalArgumentException if {@code map} is not empty
     */
    AbstractMapBasedMultimap(Map<K, Collection<V>> map) {
        checkArgument(map.isEmpty());
        this.map = map;
    }

    
Used during deserialization only.
/**
     * Used during deserialization only.
     */
    final void setMap(Map<K, Collection<V>> map) {
        this.map = map;
        totalSize = 0;
        for (Collection<V> values : map.values()) {
            checkArgument(!values.isEmpty());
            totalSize += values.size();
        }
    }

    
Creates an unmodifiable, empty collection of values.

This is used in removeAll on an empty key. /**
     * Creates an unmodifiable, empty collection of values.
     * <p>
     * <p>This is used in {@link #removeAll} on an empty key.
     */
    Collection<V> createUnmodifiableEmptyCollection() {
        return unmodifiableCollectionSubclass(createCollection());
    }

    
Creates the collection of values for a single key.

Collections with weak, soft, or phantom references are not supported. Each call to createCollection should create a new instance. 

The returned collection class determines whether duplicate key-value
pairs are allowed.
Returns:
an empty collection of values/**
     * Creates the collection of values for a single key.
     * <p>
     * <p>Collections with weak, soft, or phantom references are not supported.
     * Each call to {@code createCollection} should create a new instance.
     * <p>
     * <p>The returned collection class determines whether duplicate key-value
     * pairs are allowed.
     *
     * @return an empty collection of values
     */
    abstract Collection<V> createCollection();

    
Creates the collection of values for an explicitly provided key. By default, it simply calls createCollection(), which is the correct behavior for most implementations. The LinkedHashMultimap class overrides it. 
Params:
key – key to associate with values in the collection
Returns:
an empty collection of values/**
     * Creates the collection of values for an explicitly provided key. By
     * default, it simply calls {@link #createCollection()}, which is the correct
     * behavior for most implementations. The {@link LinkedHashMultimap} class
     * overrides it.
     *
     * @param key key to associate with values in the collection
     * @return an empty collection of values
     */
    Collection<V> createCollection(K key) {
        return createCollection();
    }

    // Query Operations

    Map<K, Collection<V>> backingMap() {
        return map;
    }

    @Override
    public int size() {
        return totalSize;
    }

    // Modification Operations

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public boolean put(K key, V value) {
        Collection<V> collection = map.get(key);
        if (collection == null) {
            collection = createCollection(key);
            if (collection.add(value)) {
                totalSize++;
                map.put(key, collection);
                return true;
            } else {
                throw new AssertionError("New Collection violated the Collection spec");
            }
        } else if (collection.add(value)) {
            totalSize++;
            return true;
        } else {
            return false;
        }
    }

    // Bulk Operations

    
{@inheritDoc}

The returned collection is immutable.
/**
     * {@inheritDoc}
     * <p>
     * <p>The returned collection is immutable.
     */
    @Override
    public Collection<V> removeAll(Object key) {
        Collection<V> collection = map.remove(key);

        if (collection == null) {
            return createUnmodifiableEmptyCollection();
        }

        Collection<V> output = createCollection();
        output.addAll(collection);
        totalSize -= collection.size();
        collection.clear();

        return unmodifiableCollectionSubclass(output);
    }

    Collection<V> unmodifiableCollectionSubclass(Collection<V> collection) {
        // We don't deal with NavigableSet here yet for GWT reasons -- instead,
        // non-GWT TreeMultimap explicitly overrides this and uses NavigableSet.
        if (collection instanceof SortedSet) {
            return Collections.unmodifiableSortedSet((SortedSet<V>) collection);
        } else if (collection instanceof Set) {
            return Collections.unmodifiableSet((Set<V>) collection);
        } else if (collection instanceof List) {
            return Collections.unmodifiableList((List<V>) collection);
        } else {
            return Collections.unmodifiableCollection(collection);
        }
    }

    // Views

    @Override
    public void clear() {
        // Clear each collection, to make previously returned collections empty.
        for (Collection<V> collection : map.values()) {
            collection.clear();
        }
        map.clear();
        totalSize = 0;
    }

    
{@inheritDoc}

The returned collection is not serializable.
/**
     * {@inheritDoc}
     * <p>
     * <p>The returned collection is not serializable.
     */
    @Override
    public Collection<V> get(K key) {
        Collection<V> collection = map.get(key);
        if (collection == null) {
            collection = createCollection(key);
        }
        return wrapCollection(key, collection);
    }

    
Generates a decorated collection that remains consistent with the values in
the multimap for the provided key. Changes to the multimap may alter the
returned collection, and vice versa.
/**
     * Generates a decorated collection that remains consistent with the values in
     * the multimap for the provided key. Changes to the multimap may alter the
     * returned collection, and vice versa.
     */
    Collection<V> wrapCollection(K key, Collection<V> collection) {
        // We don't deal with NavigableSet here yet for GWT reasons -- instead,
        // non-GWT TreeMultimap explicitly overrides this and uses NavigableSet.
        if (collection instanceof SortedSet) {
            return new WrappedSortedSet(key, (SortedSet<V>) collection, null);
        } else if (collection instanceof Set) {
            return new WrappedSet(key, (Set<V>) collection);
        } else if (collection instanceof List) {
            return wrapList(key, (List<V>) collection, null);
        } else {
            return new WrappedCollection(key, collection, null);
        }
    }

    private List<V> wrapList(
            K key, List<V> list, WrappedCollection ancestor) {
        return (list instanceof RandomAccess)
                ? new RandomAccessWrappedList(key, list, ancestor)
                : new WrappedList(key, list, ancestor);
    }

    private Iterator<V> iteratorOrListIterator(Collection<V> collection) {
        return (collection instanceof List)
                ? ((List<V>) collection).listIterator()
                : collection.iterator();
    }

    @Override
    Set<K> createKeySet() {
        // TreeMultimap uses NavigableKeySet explicitly, but we don't handle that here for GWT
        // compatibility reasons
        return (map instanceof SortedMap)
                ? new SortedKeySet((SortedMap<K, Collection<V>>) map) : new KeySet(map);
    }

    
Removes all values for the provided key. Unlike removeAll, it returns the number of removed mappings. /**
     * Removes all values for the provided key. Unlike {@link #removeAll}, it
     * returns the number of removed mappings.
     */
    private int removeValuesForKey(Object key) {
        Collection<V> collection = Maps.safeRemove(map, key);

        int count = 0;
        if (collection != null) {
            count = collection.size();
            collection.clear();
            totalSize -= count;
        }
        return count;
    }

    
{@inheritDoc}

The iterator generated by the returned collection traverses the values
for one key, followed by the values of a second key, and so on.
/**
     * {@inheritDoc}
     * <p>
     * <p>The iterator generated by the returned collection traverses the values
     * for one key, followed by the values of a second key, and so on.
     */
    @Override
    public Collection<V> values() {
        return super.values();
    }

    @Override
    Iterator<V> valueIterator() {
        return new Itr<V>() {
            @Override
            V output(K key, V value) {
                return value;
            }
        };
    }

    
{@inheritDoc}

The iterator generated by the returned collection traverses the values
for one key, followed by the values of a second key, and so on.

Each entry is an immutable snapshot of a key-value mapping in the
multimap, taken at the time the entry is returned by a method call to the
collection or its iterator.
/**
     * {@inheritDoc}
     * <p>
     * <p>The iterator generated by the returned collection traverses the values
     * for one key, followed by the values of a second key, and so on.
     * <p>
     * <p>Each entry is an immutable snapshot of a key-value mapping in the
     * multimap, taken at the time the entry is returned by a method call to the
     * collection or its iterator.
     */
    @Override
    public Collection<Entry<K, V>> entries() {
        return super.entries();
    }

    
Returns an iterator across all key-value map entries, used by 
entries().iterator() and values().iterator(). The default behavior, which traverses the values for one key, the values for a second key, and so on, suffices for most AbstractMapBasedMultimap implementations. 
Returns:
an iterator across map entries/**
     * Returns an iterator across all key-value map entries, used by {@code
     * entries().iterator()} and {@code values().iterator()}. The default
     * behavior, which traverses the values for one key, the values for a second
     * key, and so on, suffices for most {@code AbstractMapBasedMultimap} implementations.
     *
     * @return an iterator across map entries
     */
    @Override
    Iterator<Entry<K, V>> entryIterator() {
        return new Itr<Entry<K, V>>() {
            @Override
            Entry<K, V> output(K key, V value) {
                return Maps.immutableEntry(key, value);
            }
        };
    }

    @Override
    Map<K, Collection<V>> createAsMap() {
        // TreeMultimap uses NavigableAsMap explicitly, but we don't handle that here for GWT
        // compatibility reasons
        return (map instanceof SortedMap)
                ? new SortedAsMap((SortedMap<K, Collection<V>>) map) : new AsMap(map);
    }

    
Collection decorator that stays in sync with the multimap values for a key.
There are two kinds of wrapped collections: full and subcollections. Both
have a delegate pointing to the underlying collection class.

Full collections, identified by a null ancestor field, contain all multimap values for a given key. Its delegate is a value in AbstractMapBasedMultimap.map whenever the delegate is non-empty. The 
refreshIfEmpty, removeIfEmpty, and addToMap methods ensure that the WrappedCollection and map remain consistent. 

A subcollection, such as a sublist, contains some of the values for a given key. Its ancestor field points to the full wrapped collection with all values for the key. The subcollection refreshIfEmpty, 
removeIfEmpty, and addToMap methods call the corresponding methods of the full wrapped collection. /**
     * Collection decorator that stays in sync with the multimap values for a key.
     * There are two kinds of wrapped collections: full and subcollections. Both
     * have a delegate pointing to the underlying collection class.
     * <p>
     * <p>Full collections, identified by a null ancestor field, contain all
     * multimap values for a given key. Its delegate is a value in {@link
     * AbstractMapBasedMultimap#map} whenever the delegate is non-empty. The {@code
     * refreshIfEmpty}, {@code removeIfEmpty}, and {@code addToMap} methods ensure
     * that the {@code WrappedCollection} and map remain consistent.
     * <p>
     * <p>A subcollection, such as a sublist, contains some of the values for a
     * given key. Its ancestor field points to the full wrapped collection with
     * all values for the key. The subcollection {@code refreshIfEmpty}, {@code
     * removeIfEmpty}, and {@code addToMap} methods call the corresponding methods
     * of the full wrapped collection.
     */
    private class WrappedCollection extends AbstractCollection<V> {
        final K key;
        final WrappedCollection ancestor;
        final Collection<V> ancestorDelegate;
        Collection<V> delegate;

        WrappedCollection(K key, Collection<V> delegate,
                          WrappedCollection ancestor) {
            this.key = key;
            this.delegate = delegate;
            this.ancestor = ancestor;
            this.ancestorDelegate
                    = (ancestor == null) ? null : ancestor.getDelegate();
        }

        
If the delegate collection is empty, but the multimap has values for the
key, replace the delegate with the new collection for the key.

For a subcollection, refresh its ancestor and validate that the
ancestor delegate hasn't changed.
/**
         * If the delegate collection is empty, but the multimap has values for the
         * key, replace the delegate with the new collection for the key.
         * <p>
         * <p>For a subcollection, refresh its ancestor and validate that the
         * ancestor delegate hasn't changed.
         */
        void refreshIfEmpty() {
            if (ancestor != null) {
                ancestor.refreshIfEmpty();
                if (ancestor.getDelegate() != ancestorDelegate) {
                    throw new ConcurrentModificationException();
                }
            } else if (delegate.isEmpty()) {
                Collection<V> newDelegate = map.get(key);
                if (newDelegate != null) {
                    delegate = newDelegate;
                }
            }
        }

        
If collection is empty, remove it from AbstractMapBasedMultimap.this.map. For subcollections, check whether the ancestor collection is empty. /**
         * If collection is empty, remove it from {@code AbstractMapBasedMultimap.this.map}.
         * For subcollections, check whether the ancestor collection is empty.
         */
        void removeIfEmpty() {
            if (ancestor != null) {
                ancestor.removeIfEmpty();
            } else if (delegate.isEmpty()) {
                map.remove(key);
            }
        }

        K getKey() {
            return key;
        }

        
Add the delegate to the map. Other WrappedCollection methods should call this method after adding elements to a previously empty collection. 

Subcollection add the ancestor's delegate instead.
/**
         * Add the delegate to the map. Other {@code WrappedCollection} methods
         * should call this method after adding elements to a previously empty
         * collection.
         * <p>
         * <p>Subcollection add the ancestor's delegate instead.
         */
        void addToMap() {
            if (ancestor != null) {
                ancestor.addToMap();
            } else {
                map.put(key, delegate);
            }
        }

        @Override
        public int size() {
            refreshIfEmpty();
            return delegate.size();
        }

        @Override
        public boolean equals(Object object) {
            if (object == this) {
                return true;
            }
            refreshIfEmpty();
            return delegate.equals(object);
        }

        @Override
        public int hashCode() {
            refreshIfEmpty();
            return delegate.hashCode();
        }

        @Override
        public String toString() {
            refreshIfEmpty();
            return delegate.toString();
        }

        Collection<V> getDelegate() {
            return delegate;
        }

        @Override
        public Iterator<V> iterator() {
            refreshIfEmpty();
            return new WrappedIterator();
        }

        @Override
        public boolean add(V value) {
            refreshIfEmpty();
            boolean wasEmpty = delegate.isEmpty();
            boolean changed = delegate.add(value);
            if (changed) {
                totalSize++;
                if (wasEmpty) {
                    addToMap();
                }
            }
            return changed;
        }

        WrappedCollection getAncestor() {
            return ancestor;
        }

        @Override
        public boolean addAll(Collection<? extends V> collection) {
            if (collection.isEmpty()) {
                return false;
            }
            int oldSize = size();  // calls refreshIfEmpty
            boolean changed = delegate.addAll(collection);
            if (changed) {
                int newSize = delegate.size();
                totalSize += (newSize - oldSize);
                if (oldSize == 0) {
                    addToMap();
                }
            }
            return changed;
        }

        // The following methods are provided for better performance.

        @Override
        public boolean contains(Object o) {
            refreshIfEmpty();
            return delegate.contains(o);
        }

        @Override
        public boolean containsAll(Collection<?> c) {
            refreshIfEmpty();
            return delegate.containsAll(c);
        }

        @Override
        public void clear() {
            int oldSize = size();  // calls refreshIfEmpty
            if (oldSize == 0) {
                return;
            }
            delegate.clear();
            totalSize -= oldSize;
            removeIfEmpty();       // maybe shouldn't be removed if this is a sublist
        }

        @Override
        public boolean remove(Object o) {
            refreshIfEmpty();
            boolean changed = delegate.remove(o);
            if (changed) {
                totalSize--;
                removeIfEmpty();
            }
            return changed;
        }

        @Override
        public boolean removeAll(Collection<?> c) {
            if (c.isEmpty()) {
                return false;
            }
            int oldSize = size();  // calls refreshIfEmpty
            boolean changed = delegate.removeAll(c);
            if (changed) {
                int newSize = delegate.size();
                totalSize += (newSize - oldSize);
                removeIfEmpty();
            }
            return changed;
        }

        @Override
        public boolean retainAll(Collection<?> c) {
            checkNotNull(c);
            int oldSize = size();  // calls refreshIfEmpty
            boolean changed = delegate.retainAll(c);
            if (changed) {
                int newSize = delegate.size();
                totalSize += (newSize - oldSize);
                removeIfEmpty();
            }
            return changed;
        }

        
Collection iterator for WrappedCollection. /**
         * Collection iterator for {@code WrappedCollection}.
         */
        class WrappedIterator implements Iterator<V> {
            final Iterator<V> delegateIterator;
            final Collection<V> originalDelegate = delegate;

            WrappedIterator() {
                delegateIterator = iteratorOrListIterator(delegate);
            }

            WrappedIterator(Iterator<V> delegateIterator) {
                this.delegateIterator = delegateIterator;
            }

            
If the delegate changed since the iterator was created, the iterator is
no longer valid.
/**
             * If the delegate changed since the iterator was created, the iterator is
             * no longer valid.
             */
            void validateIterator() {
                refreshIfEmpty();
                if (delegate != originalDelegate) {
                    throw new ConcurrentModificationException();
                }
            }

            @Override
            public boolean hasNext() {
                validateIterator();
                return delegateIterator.hasNext();
            }

            @Override
            public V next() {
                validateIterator();
                return delegateIterator.next();
            }

            @Override
            public void remove() {
                delegateIterator.remove();
                totalSize--;
                removeIfEmpty();
            }

            Iterator<V> getDelegateIterator() {
                validateIterator();
                return delegateIterator;
            }
        }
    }

    
Set decorator that stays in sync with the multimap values for a key.
/**
     * Set decorator that stays in sync with the multimap values for a key.
     */
    private class WrappedSet extends WrappedCollection implements Set<V> {
        WrappedSet(K key, Set<V> delegate) {
            super(key, delegate, null);
        }

        @Override
        public boolean removeAll(Collection<?> c) {
            if (c.isEmpty()) {
                return false;
            }
            int oldSize = size();  // calls refreshIfEmpty

            // Guava issue 1013: AbstractSet and most JDK set implementations are
            // susceptible to quadratic removeAll performance on lists;
            // use a slightly smarter implementation here
            boolean changed = Sets.removeAllImpl((Set<V>) delegate, c);
            if (changed) {
                int newSize = delegate.size();
                totalSize += (newSize - oldSize);
                removeIfEmpty();
            }
            return changed;
        }
    }

    
SortedSet decorator that stays in sync with the multimap values for a key.
/**
     * SortedSet decorator that stays in sync with the multimap values for a key.
     */
    private class WrappedSortedSet extends WrappedCollection
            implements SortedSet<V> {
        WrappedSortedSet(K key, SortedSet<V> delegate,
                         WrappedCollection ancestor) {
            super(key, delegate, ancestor);
        }

        SortedSet<V> getSortedSetDelegate() {
            return (SortedSet<V>) getDelegate();
        }

        @Override
        public Comparator<? super V> comparator() {
            return getSortedSetDelegate().comparator();
        }

        @Override
        public V first() {
            refreshIfEmpty();
            return getSortedSetDelegate().first();
        }

        @Override
        public V last() {
            refreshIfEmpty();
            return getSortedSetDelegate().last();
        }

        @Override
        public SortedSet<V> headSet(V toElement) {
            refreshIfEmpty();
            return new WrappedSortedSet(
                    getKey(), getSortedSetDelegate().headSet(toElement),
                    (getAncestor() == null) ? this : getAncestor());
        }

        @Override
        public SortedSet<V> subSet(V fromElement, V toElement) {
            refreshIfEmpty();
            return new WrappedSortedSet(
                    getKey(), getSortedSetDelegate().subSet(fromElement, toElement),
                    (getAncestor() == null) ? this : getAncestor());
        }

        @Override
        public SortedSet<V> tailSet(V fromElement) {
            refreshIfEmpty();
            return new WrappedSortedSet(
                    getKey(), getSortedSetDelegate().tailSet(fromElement),
                    (getAncestor() == null) ? this : getAncestor());
        }
    }

    class WrappedNavigableSet extends WrappedSortedSet implements NavigableSet<V> {
        WrappedNavigableSet(
                K key, NavigableSet<V> delegate, WrappedCollection ancestor) {
            super(key, delegate, ancestor);
        }

        @Override
        NavigableSet<V> getSortedSetDelegate() {
            return (NavigableSet<V>) super.getSortedSetDelegate();
        }

        @Override
        public V lower(V v) {
            return getSortedSetDelegate().lower(v);
        }

        @Override
        public V floor(V v) {
            return getSortedSetDelegate().floor(v);
        }

        @Override
        public V ceiling(V v) {
            return getSortedSetDelegate().ceiling(v);
        }

        @Override
        public V higher(V v) {
            return getSortedSetDelegate().higher(v);
        }

        @Override
        public V pollFirst() {
            return Iterators.pollNext(iterator());
        }

        @Override
        public V pollLast() {
            return Iterators.pollNext(descendingIterator());
        }

        private NavigableSet<V> wrap(NavigableSet<V> wrapped) {
            return new WrappedNavigableSet(key, wrapped,
                    (getAncestor() == null) ? this : getAncestor());
        }

        @Override
        public NavigableSet<V> descendingSet() {
            return wrap(getSortedSetDelegate().descendingSet());
        }

        @Override
        public Iterator<V> descendingIterator() {
            return new AbstractMapBasedMultimap.WrappedCollection.WrappedIterator(getSortedSetDelegate()
                    .descendingIterator());
        }

        @Override
        public NavigableSet<V> subSet(
                V fromElement, boolean fromInclusive, V toElement, boolean toInclusive) {
            return wrap(
                    getSortedSetDelegate().subSet(fromElement, fromInclusive, toElement, toInclusive));
        }

        @Override
        public NavigableSet<V> headSet(V toElement, boolean inclusive) {
            return wrap(getSortedSetDelegate().headSet(toElement, inclusive));
        }

        @Override
        public NavigableSet<V> tailSet(V fromElement, boolean inclusive) {
            return wrap(getSortedSetDelegate().tailSet(fromElement, inclusive));
        }
    }

    
List decorator that stays in sync with the multimap values for a key.
/**
     * List decorator that stays in sync with the multimap values for a key.
     */
    private class WrappedList extends WrappedCollection implements List<V> {
        WrappedList(K key, List<V> delegate,
                    WrappedCollection ancestor) {
            super(key, delegate, ancestor);
        }

        List<V> getListDelegate() {
            return (List<V>) getDelegate();
        }

        @Override
        public boolean addAll(int index, Collection<? extends V> c) {
            if (c.isEmpty()) {
                return false;
            }
            int oldSize = size();  // calls refreshIfEmpty
            boolean changed = getListDelegate().addAll(index, c);
            if (changed) {
                int newSize = getDelegate().size();
                totalSize += (newSize - oldSize);
                if (oldSize == 0) {
                    addToMap();
                }
            }
            return changed;
        }

        @Override
        public V get(int index) {
            refreshIfEmpty();
            return getListDelegate().get(index);
        }

        @Override
        public V set(int index, V element) {
            refreshIfEmpty();
            return getListDelegate().set(index, element);
        }

        @Override
        public void add(int index, V element) {
            refreshIfEmpty();
            boolean wasEmpty = getDelegate().isEmpty();
            getListDelegate().add(index, element);
            totalSize++;
            if (wasEmpty) {
                addToMap();
            }
        }

        @Override
        public V remove(int index) {
            refreshIfEmpty();
            V value = getListDelegate().remove(index);
            totalSize--;
            removeIfEmpty();
            return value;
        }

        @Override
        public int indexOf(Object o) {
            refreshIfEmpty();
            return getListDelegate().indexOf(o);
        }

        @Override
        public int lastIndexOf(Object o) {
            refreshIfEmpty();
            return getListDelegate().lastIndexOf(o);
        }

        @Override
        public ListIterator<V> listIterator() {
            refreshIfEmpty();
            return new WrappedListIterator();
        }

        @Override
        public ListIterator<V> listIterator(int index) {
            refreshIfEmpty();
            return new WrappedListIterator(index);
        }

        @Override
        public List<V> subList(int fromIndex, int toIndex) {
            refreshIfEmpty();
            return wrapList(
                    getKey(),
                    getListDelegate().subList(fromIndex, toIndex),
                    (getAncestor() == null) ? this : getAncestor());
        }

        
ListIterator decorator.
/**
         * ListIterator decorator.
         */
        private class WrappedListIterator extends WrappedIterator
                implements ListIterator<V> {
            WrappedListIterator() {
            }

            public WrappedListIterator(int index) {
                super(getListDelegate().listIterator(index));
            }

            private ListIterator<V> getDelegateListIterator() {
                return (ListIterator<V>) getDelegateIterator();
            }

            @Override
            public boolean hasPrevious() {
                return getDelegateListIterator().hasPrevious();
            }

            @Override
            public V previous() {
                return getDelegateListIterator().previous();
            }

            @Override
            public int nextIndex() {
                return getDelegateListIterator().nextIndex();
            }

            @Override
            public int previousIndex() {
                return getDelegateListIterator().previousIndex();
            }

            @Override
            public void set(V value) {
                getDelegateListIterator().set(value);
            }

            @Override
            public void add(V value) {
                boolean wasEmpty = isEmpty();
                getDelegateListIterator().add(value);
                totalSize++;
                if (wasEmpty) {
                    addToMap();
                }
            }
        }
    }

    
List decorator that stays in sync with the multimap values for a key and
supports rapid random access.
/**
     * List decorator that stays in sync with the multimap values for a key and
     * supports rapid random access.
     */
    private class RandomAccessWrappedList extends WrappedList
            implements RandomAccess {
        RandomAccessWrappedList(K key, List<V> delegate,
                                WrappedCollection ancestor) {
            super(key, delegate, ancestor);
        }
    }

  /*
   * TODO(kevinb): should we copy this javadoc to each concrete class, so that
   * classes like LinkedHashMultimap that need to say something different are
   * still able to {@inheritDoc} all the way from Multimap?
   */

    private class KeySet extends Maps.KeySet<K, Collection<V>> {
        KeySet(final Map<K, Collection<V>> subMap) {
            super(subMap);
        }

        @Override
        public Iterator<K> iterator() {
            final Iterator<Entry<K, Collection<V>>> entryIterator
                    = map().entrySet().iterator();
            return new Iterator<K>() {
                Entry<K, Collection<V>> entry;

                @Override
                public boolean hasNext() {
                    return entryIterator.hasNext();
                }

                @Override
                public K next() {
                    entry = entryIterator.next();
                    return entry.getKey();
                }

                @Override
                public void remove() {
                    CollectPreconditions.checkRemove(entry != null);
                    Collection<V> collection = entry.getValue();
                    entryIterator.remove();
                    totalSize -= collection.size();
                    collection.clear();
                }
            };
        }

        // The following methods are included for better performance.

        @Override
        public boolean remove(Object key) {
            int count = 0;
            Collection<V> collection = map().remove(key);
            if (collection != null) {
                count = collection.size();
                collection.clear();
                totalSize -= count;
            }
            return count > 0;
        }

        @Override
        public void clear() {
            Iterators.clear(iterator());
        }

        @Override
        public boolean containsAll(Collection<?> c) {
            return map().keySet().containsAll(c);
        }

        @Override
        public boolean equals(Object object) {
            return this == object || this.map().keySet().equals(object);
        }

        @Override
        public int hashCode() {
            return map().keySet().hashCode();
        }
    }

    private class SortedKeySet extends KeySet implements SortedSet<K> {

        SortedKeySet(SortedMap<K, Collection<V>> subMap) {
            super(subMap);
        }

        SortedMap<K, Collection<V>> sortedMap() {
            return (SortedMap<K, Collection<V>>) super.map();
        }

        @Override
        public Comparator<? super K> comparator() {
            return sortedMap().comparator();
        }

        @Override
        public K first() {
            return sortedMap().firstKey();
        }

        @Override
        public SortedSet<K> headSet(K toElement) {
            return new SortedKeySet(sortedMap().headMap(toElement));
        }

        @Override
        public K last() {
            return sortedMap().lastKey();
        }

        @Override
        public SortedSet<K> subSet(K fromElement, K toElement) {
            return new SortedKeySet(sortedMap().subMap(fromElement, toElement));
        }

        @Override
        public SortedSet<K> tailSet(K fromElement) {
            return new SortedKeySet(sortedMap().tailMap(fromElement));
        }
    }

    class NavigableKeySet extends SortedKeySet implements NavigableSet<K> {
        NavigableKeySet(NavigableMap<K, Collection<V>> subMap) {
            super(subMap);
        }

        @Override
        NavigableMap<K, Collection<V>> sortedMap() {
            return (NavigableMap<K, Collection<V>>) super.sortedMap();
        }

        @Override
        public K lower(K k) {
            return sortedMap().lowerKey(k);
        }

        @Override
        public K floor(K k) {
            return sortedMap().floorKey(k);
        }

        @Override
        public K ceiling(K k) {
            return sortedMap().ceilingKey(k);
        }

        @Override
        public K higher(K k) {
            return sortedMap().higherKey(k);
        }

        @Override
        public K pollFirst() {
            return Iterators.pollNext(iterator());
        }

        @Override
        public K pollLast() {
            return Iterators.pollNext(descendingIterator());
        }

        @Override
        public NavigableSet<K> descendingSet() {
            return new NavigableKeySet(sortedMap().descendingMap());
        }

        @Override
        public Iterator<K> descendingIterator() {
            return descendingSet().iterator();
        }

        @Override
        public NavigableSet<K> headSet(K toElement) {
            return headSet(toElement, false);
        }

        @Override
        public NavigableSet<K> headSet(K toElement, boolean inclusive) {
            return new NavigableKeySet(sortedMap().headMap(toElement, inclusive));
        }

        @Override
        public NavigableSet<K> subSet(K fromElement, K toElement) {
            return subSet(fromElement, true, toElement, false);
        }

        @Override
        public NavigableSet<K> subSet(
                K fromElement, boolean fromInclusive, K toElement, boolean toInclusive) {
            return new NavigableKeySet(
                    sortedMap().subMap(fromElement, fromInclusive, toElement, toInclusive));
        }

        @Override
        public NavigableSet<K> tailSet(K fromElement) {
            return tailSet(fromElement, true);
        }

        @Override
        public NavigableSet<K> tailSet(K fromElement, boolean inclusive) {
            return new NavigableKeySet(sortedMap().tailMap(fromElement, inclusive));
        }
    }

    private abstract class Itr<T> implements Iterator<T> {
        final Iterator<Entry<K, Collection<V>>> keyIterator;
        K key;
        Collection<V> collection;
        Iterator<V> valueIterator;

        Itr() {
            keyIterator = map.entrySet().iterator();
            key = null;
            collection = null;
            valueIterator = Iterators.emptyModifiableIterator();
        }

        abstract T output(K key, V value);

        @Override
        public boolean hasNext() {
            return keyIterator.hasNext() || valueIterator.hasNext();
        }

        @Override
        public T next() {
            if (!valueIterator.hasNext()) {
                Entry<K, Collection<V>> mapEntry = keyIterator.next();
                key = mapEntry.getKey();
                collection = mapEntry.getValue();
                valueIterator = collection.iterator();
            }
            return output(key, valueIterator.next());
        }

        @Override
        public void remove() {
            valueIterator.remove();
            if (collection.isEmpty()) {
                keyIterator.remove();
            }
            totalSize--;
        }
    }

    private class AsMap extends Maps.ImprovedAbstractMap<K, Collection<V>> {
        
Usually the same as map, but smaller for the headMap(), tailMap(), or
subMap() of a SortedAsMap.
/**
         * Usually the same as map, but smaller for the headMap(), tailMap(), or
         * subMap() of a SortedAsMap.
         */
        final transient Map<K, Collection<V>> submap;

        AsMap(Map<K, Collection<V>> submap) {
            this.submap = submap;
        }

        @Override
        protected Set<Entry<K, Collection<V>>> createEntrySet() {
            return new AsMapEntries();
        }

        // The following methods are included for performance.

        @Override
        public boolean containsKey(Object key) {
            return Maps.safeContainsKey(submap, key);
        }

        @Override
        public Collection<V> get(Object key) {
            Collection<V> collection = Maps.safeGet(submap, key);
            if (collection == null) {
                return null;
            }
            @SuppressWarnings("unchecked")
            K k = (K) key;
            return wrapCollection(k, collection);
        }

        @Override
        public Set<K> keySet() {
            return AbstractMapBasedMultimap.this.keySet();
        }

        @Override
        public int size() {
            return submap.size();
        }

        @Override
        public Collection<V> remove(Object key) {
            Collection<V> collection = submap.remove(key);
            if (collection == null) {
                return null;
            }

            Collection<V> output = createCollection();
            output.addAll(collection);
            totalSize -= collection.size();
            collection.clear();
            return output;
        }

        @Override
        public boolean equals(Object object) {
            return this == object || submap.equals(object);
        }

        @Override
        public int hashCode() {
            return submap.hashCode();
        }

        @Override
        public String toString() {
            return submap.toString();
        }

        @Override
        public void clear() {
            if (submap == map) {
                AbstractMapBasedMultimap.this.clear();
            } else {
                Iterators.clear(new AsMapIterator());
            }
        }

        Entry<K, Collection<V>> wrapEntry(Entry<K, Collection<V>> entry) {
            K key = entry.getKey();
            return Maps.immutableEntry(key, wrapCollection(key, entry.getValue()));
        }

        class AsMapEntries extends Maps.EntrySet<K, Collection<V>> {
            @Override
            Map<K, Collection<V>> map() {
                return AbstractMapBasedMultimap.AsMap.this;
            }

            @Override
            public Iterator<Entry<K, Collection<V>>> iterator() {
                return new AsMapIterator();
            }

            // The following methods are included for performance.

            @Override
            public boolean contains(Object o) {
                return Collections2.safeContains(submap.entrySet(), o);
            }

            @Override
            public boolean remove(Object o) {
                if (!contains(o)) {
                    return false;
                }
                Entry<?, ?> entry = (Entry<?, ?>) o;
                removeValuesForKey(entry.getKey());
                return true;
            }
        }

        
Iterator across all keys and value collections.
/**
         * Iterator across all keys and value collections.
         */
        class AsMapIterator implements Iterator<Entry<K, Collection<V>>> {
            final Iterator<Entry<K, Collection<V>>> delegateIterator
                    = submap.entrySet().iterator();
            Collection<V> collection;

            @Override
            public boolean hasNext() {
                return delegateIterator.hasNext();
            }

            @Override
            public Entry<K, Collection<V>> next() {
                Entry<K, Collection<V>> entry = delegateIterator.next();
                collection = entry.getValue();
                return wrapEntry(entry);
            }

            @Override
            public void remove() {
                delegateIterator.remove();
                totalSize -= collection.size();
                collection.clear();
            }
        }
    }

    private class SortedAsMap extends AsMap
            implements SortedMap<K, Collection<V>> {
        SortedSet<K> sortedKeySet;

        SortedAsMap(SortedMap<K, Collection<V>> submap) {
            super(submap);
        }

        SortedMap<K, Collection<V>> sortedMap() {
            return (SortedMap<K, Collection<V>>) submap;
        }

        @Override
        public Comparator<? super K> comparator() {
            return sortedMap().comparator();
        }

        @Override
        public K firstKey() {
            return sortedMap().firstKey();
        }

        @Override
        public K lastKey() {
            return sortedMap().lastKey();
        }

        @Override
        public SortedMap<K, Collection<V>> headMap(K toKey) {
            return new SortedAsMap(sortedMap().headMap(toKey));
        }

        @Override
        public SortedMap<K, Collection<V>> subMap(K fromKey, K toKey) {
            return new SortedAsMap(sortedMap().subMap(fromKey, toKey));
        }

        @Override
        public SortedMap<K, Collection<V>> tailMap(K fromKey) {
            return new SortedAsMap(sortedMap().tailMap(fromKey));
        }

        // returns a SortedSet, even though returning a Set would be sufficient to
        // satisfy the SortedMap.keySet() interface
        @Override
        public SortedSet<K> keySet() {
            SortedSet<K> result = sortedKeySet;
            return (result == null) ? sortedKeySet = createKeySet() : result;
        }

        @Override
        SortedSet<K> createKeySet() {
            return new SortedKeySet(sortedMap());
        }
    }

    class NavigableAsMap extends SortedAsMap implements NavigableMap<K, Collection<V>> {

        NavigableAsMap(NavigableMap<K, Collection<V>> submap) {
            super(submap);
        }

        @Override
        NavigableMap<K, Collection<V>> sortedMap() {
            return (NavigableMap<K, Collection<V>>) super.sortedMap();
        }

        @Override
        public Entry<K, Collection<V>> lowerEntry(K key) {
            Entry<K, Collection<V>> entry = sortedMap().lowerEntry(key);
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public K lowerKey(K key) {
            return sortedMap().lowerKey(key);
        }

        @Override
        public Entry<K, Collection<V>> floorEntry(K key) {
            Entry<K, Collection<V>> entry = sortedMap().floorEntry(key);
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public K floorKey(K key) {
            return sortedMap().floorKey(key);
        }

        @Override
        public Entry<K, Collection<V>> ceilingEntry(K key) {
            Entry<K, Collection<V>> entry = sortedMap().ceilingEntry(key);
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public K ceilingKey(K key) {
            return sortedMap().ceilingKey(key);
        }

        @Override
        public Entry<K, Collection<V>> higherEntry(K key) {
            Entry<K, Collection<V>> entry = sortedMap().higherEntry(key);
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public K higherKey(K key) {
            return sortedMap().higherKey(key);
        }

        @Override
        public Entry<K, Collection<V>> firstEntry() {
            Entry<K, Collection<V>> entry = sortedMap().firstEntry();
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public Entry<K, Collection<V>> lastEntry() {
            Entry<K, Collection<V>> entry = sortedMap().lastEntry();
            return (entry == null) ? null : wrapEntry(entry);
        }

        @Override
        public Entry<K, Collection<V>> pollFirstEntry() {
            return pollAsMapEntry(entrySet().iterator());
        }

        @Override
        public Entry<K, Collection<V>> pollLastEntry() {
            return pollAsMapEntry(descendingMap().entrySet().iterator());
        }

        Entry<K, Collection<V>> pollAsMapEntry(Iterator<Entry<K, Collection<V>>> entryIterator) {
            if (!entryIterator.hasNext()) {
                return null;
            }
            Entry<K, Collection<V>> entry = entryIterator.next();
            Collection<V> output = createCollection();
            output.addAll(entry.getValue());
            entryIterator.remove();
            return Maps.immutableEntry(entry.getKey(), unmodifiableCollectionSubclass(output));
        }

        @Override
        public NavigableMap<K, Collection<V>> descendingMap() {
            return new NavigableAsMap(sortedMap().descendingMap());
        }

        @Override
        public NavigableSet<K> keySet() {
            return (NavigableSet<K>) super.keySet();
        }

        @Override
        NavigableSet<K> createKeySet() {
            return new NavigableKeySet(sortedMap());
        }

        @Override
        public NavigableSet<K> navigableKeySet() {
            return keySet();
        }

        @Override
        public NavigableSet<K> descendingKeySet() {
            return descendingMap().navigableKeySet();
        }

        @Override
        public NavigableMap<K, Collection<V>> subMap(K fromKey, K toKey) {
            return subMap(fromKey, true, toKey, false);
        }

        @Override
        public NavigableMap<K, Collection<V>> subMap(
                K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
            return new NavigableAsMap(sortedMap().subMap(fromKey, fromInclusive, toKey, toInclusive));
        }

        @Override
        public NavigableMap<K, Collection<V>> headMap(K toKey) {
            return headMap(toKey, false);
        }

        @Override
        public NavigableMap<K, Collection<V>> headMap(K toKey, boolean inclusive) {
            return new NavigableAsMap(sortedMap().headMap(toKey, inclusive));
        }

        @Override
        public NavigableMap<K, Collection<V>> tailMap(K fromKey) {
            return tailMap(fromKey, true);
        }

        @Override
        public NavigableMap<K, Collection<V>> tailMap(K fromKey, boolean inclusive) {
            return new NavigableAsMap(sortedMap().tailMap(fromKey, inclusive));
        }
    }
}