Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 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 com.google.common.collect;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.Map;
 import java.util.Set;
 
A skeleton Multimap implementation, not necessarily in terms of a Map.

Author(s):
Louis Wasserman
 
 abstract class AbstractMultimap<K, V> implements Multimap<K, V> {
   @Override
   public boolean isEmpty() {
     return size() == 0;
   }
 
   @Override
   public boolean containsValue(@Nullable Object value) {
     for (Collection<V> collection : asMap().values()) {
       if (collection.contains(value)) {
         return true;
       }
     }
 
     return false;
   }
 
   @Override
   public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
     Collection<V> collection = asMap().get(key);
     return collection != null && collection.contains(value);
   }
   
   @Override
   public boolean remove(@Nullable Object key, @Nullable Object value) {
     Collection<V> collection = asMap().get(key);
     return collection != null && collection.remove(value);
   }
 
   @Override
   public boolean put(@Nullable K key, @Nullable V value) {
     return get(key).add(value);
   }
 
   @Override
   public boolean putAll(@Nullable K keyIterable<? extends V> values) {
     checkNotNull(values);
     // make sure we only call values.iterator() once
     // and we only call get(key) if values is nonempty
     if (values instanceof Collection) {
       Collection<? extends V> valueCollection = (Collection<? extends V>) values;
       return !valueCollection.isEmpty() && get(key).addAll(valueCollection);
     } else {
       Iterator<? extends V> valueItr = values.iterator();
       return valueItr.hasNext() && Iterators.addAll(get(key), valueItr);
     }
   }
 
   @Override
   public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
     boolean changed = false;
     for (Map.Entry<? extends K, ? extends V> entry : multimap.entries()) {
       changed |= put(entry.getKey(), entry.getValue());
     }
     return changed;
   }
 
   @Override
   public Collection<V> replaceValues(@Nullable K keyIterable<? extends V> values) {
     checkNotNull(values);
     Collection<V> result = removeAll(key);
     putAll(keyvalues);
    return result;
  }
  
  private transient Collection<Entry<K, V>> entries;
  public Collection<Entry<K, V>> entries() {
    Collection<Entry<K, V>> result = ;
    return (result == null) ?  = createEntries() : result;
  }
  
    if (this instanceof SetMultimap) {
      return new EntrySet();
    } else {
      return new Entries();
    }
  }
  
  private class Entries extends Multimaps.Entries<K, V> {
    @Override
    Multimap<K, V> multimap() {
      return AbstractMultimap.this;
    }
    @Override
    public Iterator<Entry<K, V>> iterator() {
      return entryIterator();
    }
  }
  
  private class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }
    @Override
    public boolean equals(@Nullable Object obj) {
      return Sets.equalsImpl(thisobj);
    }    
  }
  
  abstract Iterator<Entry<K, V>> entryIterator();
  private transient Set<K> keySet;
  public Set<K> keySet() {
    Set<K> result = ;
    return (result == null) ?  = createKeySet() : result;
  }
  Set<K> createKeySet() {
    return new Maps.KeySet<K, Collection<V>>(asMap());
  }
  
  private transient Multiset<K> keys;
  
  public Multiset<K> keys() {
    Multiset<K> result = ;
    return (result == null) ?  = createKeys() : result;
  }
  
  Multiset<K> createKeys() {
    return new Multimaps.Keys<K, V>(this);
  }
  
  private transient Collection<V> values;
  
  public Collection<V> values() {
    Collection<V> result = ;
    return (result == null) ?  = createValues() : result;
  }
  
    return new Values();
  }
  class Values extends AbstractCollection<V> {
    @Override public Iterator<V> iterator() {
      return valueIterator();
    }
    @Override public int size() {
      return AbstractMultimap.this.size();
    }
    @Override public boolean contains(@Nullable Object o) {
      return AbstractMultimap.this.containsValue(o);
    }
    @Override public void clear() {
      AbstractMultimap.this.clear();
    }
  }
  
    return Maps.valueIterator(entries().iterator());
  }
  
  private transient Map<K, Collection<V>> asMap;
  
  public Map<K, Collection<V>> asMap() {
    Map<K, Collection<V>> result = ;
    return (result == null) ?  = createAsMap() : result;
  }
  
  abstract Map<K, Collection<V>> createAsMap();
  // Comparison and hashing
  @Override public boolean equals(@Nullable Object object) {
    return Multimaps.equalsImpl(thisobject);
  }

  
Returns the hash code for this multimap.

The hash code of a multimap is defined as the hash code of the map view, as returned by Multimap.asMap().

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

  
Returns a string representation of the multimap, generated by calling toString on the map returned by Multimap.asMap().

Returns:
a string representation of the multimap
  public String toString() {
    return asMap().toString();
  }
New to GrepCode? Check out our FAQ X