1 files changed, 84 insertions, 46 deletions
diff --git a/guava/src/com/google/common/collect/ImmutableBiMap.java b/guava/src/com/google/common/collect/ImmutableBiMap.java
index d7968b2..9d8e144 100644
--- a/guava/src/com/google/common/collect/ImmutableBiMap.java
+++ b/guava/src/com/google/common/collect/ImmutableBiMap.java
@@ -16,13 +16,12 @@
 
 package com.google.common.collect;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
 import com.google.common.annotations.GwtCompatible;
 
-import java.util.Collection;
 import java.util.Map;
 
+import javax.annotation.Nullable;
+
 /**
  * An immutable {@link BiMap} with reliable user-specified iteration order. Does
  * not permit null keys or values. An {@code ImmutableBiMap} and its inverse
@@ -44,22 +43,23 @@ import java.util.Map;
 public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
     implements BiMap<K, V> {
 
+  private static final ImmutableBiMap<Object, Object> EMPTY_IMMUTABLE_BIMAP
+      = new EmptyBiMap();
+
   /**
    * Returns the empty bimap.
    */
   // Casting to any type is safe because the set will never hold any elements.
   @SuppressWarnings("unchecked")
   public static <K, V> ImmutableBiMap<K, V> of() {
-    return (ImmutableBiMap<K, V>) EmptyImmutableBiMap.INSTANCE;
+    return (ImmutableBiMap<K, V>) EMPTY_IMMUTABLE_BIMAP;
   }
 
   /**
    * Returns an immutable bimap containing a single entry.
    */
   public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1) {
-    checkNotNull(k1, "null key in entry: null=%s", v1);
-    checkNotNull(v1, "null value in entry: %s=null", k1);
-    return new SingletonImmutableBiMap<K, V>(k1, v1);
+    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(k1, v1));
   }
 
   /**
@@ -68,10 +68,7 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
    * @throws IllegalArgumentException if duplicate keys or values are added
    */
   public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1, K k2, V v2) {
-    return new Builder<K, V>()
-        .put(k1, v1)
-        .put(k2, v2)
-        .build();
+    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(k1, v1, k2, v2));
   }
 
   /**
@@ -81,11 +78,8 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
    */
   public static <K, V> ImmutableBiMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3) {
-    return new Builder<K, V>()
-        .put(k1, v1)
-        .put(k2, v2)
-        .put(k3, v3)
-        .build();
+    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(
+        k1, v1, k2, v2, k3, v3));
   }
 
   /**
@@ -95,12 +89,8 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
    */
   public static <K, V> ImmutableBiMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
-    return new Builder<K, V>()
-        .put(k1, v1)
-        .put(k2, v2)
-        .put(k3, v3)
-        .put(k4, v4)
-        .build();
+    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(
+        k1, v1, k2, v2, k3, v3, k4, v4));
   }
 
   /**
@@ -110,13 +100,8 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
    */
   public static <K, V> ImmutableBiMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
-    return new Builder<K, V>()
-        .put(k1, v1)
-        .put(k2, v2)
-        .put(k3, v3)
-        .put(k4, v4)
-        .put(k5, v5)
-        .build();
+    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(
+        k1, v1, k2, v2, k3, v3, k4, v4, k5, v5));
   }
 
   // looking for of() with > 5 entries? Use the builder instead.
@@ -184,7 +169,11 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
      * @throws IllegalArgumentException if duplicate keys or values were added
      */
     @Override public ImmutableBiMap<K, V> build() {
-      return fromEntries(entries);
+      ImmutableMap<K, V> map = super.build();
+      if (map.isEmpty()) {
+        return of();
+      }
+      return new RegularImmutableBiMap<K, V>(map);
     }
   }
 
@@ -213,25 +202,18 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
       }
     }
 
-    return fromEntries(ImmutableList.copyOf(map.entrySet()));
-  }
-
-  static <K, V> ImmutableBiMap<K, V> fromEntries(
-      Collection<? extends Entry<? extends K, ? extends V>> entries) {
-    switch (entries.size()) {
-      case 0:
-        return of();
-      case 1: {
-        Entry<? extends K, ? extends V> entry = Iterables.getOnlyElement(entries);
-        return new SingletonImmutableBiMap<K, V>(entry.getKey(), entry.getValue());
-      }
-      default:
-        return new RegularImmutableBiMap<K, V>(entries);
+    if (map.isEmpty()) {
+      return of();
     }
+
+    ImmutableMap<K, V> immutableMap = ImmutableMap.copyOf(map);
+    return new RegularImmutableBiMap<K, V>(immutableMap);
   }
 
   ImmutableBiMap() {}
 
+  abstract ImmutableMap<K, V> delegate();
+
   /**
    * {@inheritDoc}
    *
@@ -241,6 +223,26 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
   @Override
   public abstract ImmutableBiMap<V, K> inverse();
 
+  @Override public boolean containsKey(@Nullable Object key) {
+    return delegate().containsKey(key);
+  }
+
+  @Override public boolean containsValue(@Nullable Object value) {
+    return inverse().containsKey(value);
+  }
+
+  @Override public ImmutableSet<Entry<K, V>> entrySet() {
+    return delegate().entrySet();
+  }
+
+  @Override public V get(@Nullable Object key) {
+    return delegate().get(key);
+  }
+
+  @Override public ImmutableSet<K> keySet() {
+    return delegate().keySet();
+  }
+
   /**
    * Returns an immutable set of the values in this map. The values are in the
    * same order as the parameters used to build this map.
@@ -253,14 +255,50 @@ public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
    * Guaranteed to throw an exception and leave the bimap unmodified.
    *
    * @throws UnsupportedOperationException always
-   * @deprecated Unsupported operation.
    */
-  @Deprecated
   @Override
   public V forcePut(K key, V value) {
     throw new UnsupportedOperationException();
   }
 
+  @Override public boolean isEmpty() {
+    return delegate().isEmpty();
+  }
+
+  @Override
+  public int size() {
+    return delegate().size();
+  }
+
+  @Override public boolean equals(@Nullable Object object) {
+    return object == this || delegate().equals(object);
+  }
+
+  @Override public int hashCode() {
+    return delegate().hashCode();
+  }
+
+  @Override public String toString() {
+    return delegate().toString();
+  }
+
+  /** Bimap with no mappings. */
+  @SuppressWarnings("serial") // uses writeReplace(), not default serialization
+  static class EmptyBiMap extends ImmutableBiMap<Object, Object> {
+    @Override ImmutableMap<Object, Object> delegate() {
+      return ImmutableMap.of();
+    }
+    @Override public ImmutableBiMap<Object, Object> inverse() {
+      return this;
+    }
+    @Override boolean isPartialView() {
+      return false;
+    }
+    Object readResolve() {
+      return EMPTY_IMMUTABLE_BIMAP; // preserve singleton property
+    }
+  }
+
   /**
    * Serialized type for all ImmutableBiMap instances. It captures the logical
    * contents and they are reconstructed using public factory methods. This