Update #0 - First Release

sources/main/java/com/google/common/collect/AbstractMultimap.java

@@ -0,0 +1,249 @@
+/*
+ * 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.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+import com.google.common.annotations.GwtCompatible;
+
+/**
+ * A skeleton {@code Multimap} implementation, not necessarily in terms of a
+ * {@code Map}.
+ * 
+ * @author Louis Wasserman
+ */
+@GwtCompatible
+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 key, Iterable<? 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 key, Iterable<? extends V> values) {
+		checkNotNull(values);
+		Collection<V> result = removeAll(key);
+		putAll(key, values);
+		return result;
+	}
+
+	private transient Collection<Entry<K, V>> entries;
+
+	@Override
+	public Collection<Entry<K, V>> entries() {
+		Collection<Entry<K, V>> result = entries;
+		return (result == null) ? entries = createEntries() : result;
+	}
+
+	Collection<Entry<K, V>> createEntries() {
+		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(this, obj);
+		}
+	}
+
+	abstract Iterator<Entry<K, V>> entryIterator();
+
+	private transient Set<K> keySet;
+
+	@Override
+	public Set<K> keySet() {
+		Set<K> result = keySet;
+		return (result == null) ? keySet = createKeySet() : result;
+	}
+
+	Set<K> createKeySet() {
+		return new Maps.KeySet<K, Collection<V>>(asMap());
+	}
+
+	private transient Multiset<K> keys;
+
+	@Override
+	public Multiset<K> keys() {
+		Multiset<K> result = keys;
+		return (result == null) ? keys = createKeys() : result;
+	}
+
+	Multiset<K> createKeys() {
+		return new Multimaps.Keys<K, V>(this);
+	}
+
+	private transient Collection<V> values;
+
+	@Override
+	public Collection<V> values() {
+		Collection<V> result = values;
+		return (result == null) ? values = createValues() : result;
+	}
+
+	Collection<V> createValues() {
+		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();
+		}
+	}
+
+	Iterator<V> valueIterator() {
+		return Maps.valueIterator(entries().iterator());
+	}
+
+	private transient Map<K, Collection<V>> asMap;
+
+	@Override
+	public Map<K, Collection<V>> asMap() {
+		Map<K, Collection<V>> result = asMap;
+		return (result == null) ? asMap = createAsMap() : result;
+	}
+
+	abstract Map<K, Collection<V>> createAsMap();
+
+	// Comparison and hashing
+
+	@Override
+	public boolean equals(@Nullable Object object) {
+		return Multimaps.equalsImpl(this, object);
+	}
+
+	/**
+	 * Returns the hash code for this multimap.
+	 *
+	 * <p>
+	 * The hash code of a multimap is defined as the hash code of the map view, as
+	 * returned by {@link Multimap#asMap}.
+	 *
+	 * @see Map#hashCode
+	 */
+	@Override
+	public int hashCode() {
+		return asMap().hashCode();
+	}
+
+	/**
+	 * Returns a string representation of the multimap, generated by calling
+	 * {@code toString} on the map returned by {@link Multimap#asMap}.
+	 *
+	 * @return a string representation of the multimap
+	 */
+	@Override
+	public String toString() {
+		return asMap().toString();
+	}
+}