Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2008 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 java.util.Map;
 
An immutable BiMap with reliable user-specified iteration order. Does not permit null keys or values. An ImmutableBiMap and its inverse have the same iteration ordering.

An instance of ImmutableBiMap contains its own data and will never change. ImmutableBiMap is convenient for public static final maps ("constant maps") and also lets you easily make a "defensive copy" of a bimap provided to your class by a caller.

Note: Although this class is not final, it cannot be subclassed as it has no public or protected constructors. Thus, instances of this class are guaranteed to be immutable.

Author(s):
Jared Levy
Since:
2.0 (imported from Google Collections Library)
 
 @GwtCompatible(serializable = true, emulated = true)
 public abstract class ImmutableBiMap<K, V> extends ImmutableMap<K, V>
     implements BiMap<K, V> {

  
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>) .;
   }

  
Returns an immutable bimap containing a single entry.
 
   public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1) {
     return new RegularImmutableBiMap<K, V>(ImmutableMap.of(k1v1));
   }

  
Returns an immutable map containing the given entries, in order.

Throws:
java.lang.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 RegularImmutableBiMap<K, V>(ImmutableMap.of(k1v1k2v2));
   }

  
Returns an immutable map containing the given entries, in order.

Throws:
java.lang.IllegalArgumentException if duplicate keys or values are added
 
   public static <K, V> ImmutableBiMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3) {
     return new RegularImmutableBiMap<K, V>(ImmutableMap.of(
         k1v1k2v2k3v3));
   }

  
Returns an immutable map containing the given entries, in order.

Throws:
java.lang.IllegalArgumentException if duplicate keys or values are added
 
   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 RegularImmutableBiMap<K, V>(ImmutableMap.of(
         k1v1k2v2k3v3k4v4));
   }

  
Returns an immutable map containing the given entries, in order.

Throws:
java.lang.IllegalArgumentException if duplicate keys or values are added
 
   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 RegularImmutableBiMap<K, V>(ImmutableMap.of(
        k1v1k2v2k3v3k4v4k5v5));
  }
  // looking for of() with > 5 entries? Use the builder instead.

  
Returns a new builder. The generated builder is equivalent to the builder created by the ImmutableBiMap.Builder constructor.
  public static <K, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }

  
A builder for creating immutable bimap instances, especially public static final bimaps ("constant bimaps"). Example:
   static final ImmutableBiMap<String, Integer> WORD_TO_INT =
       new ImmutableBiMap.Builder<String, Integer>()
           .put("one", 1)
           .put("two", 2)
           .put("three", 3)
           .build();
For small immutable bimaps, the ImmutableBiMap.of() methods are even more convenient.

Builder instances can be reused - it is safe to call build() multiple times to build multiple bimaps in series. Each bimap is a superset of the bimaps created before it.

Since:
2.0 (imported from Google Collections Library)
  public static final class Builder<K, V> extends ImmutableMap.Builder<K, V> {

    
Creates a new builder. The returned builder is equivalent to the builder generated by ImmutableBiMap.builder().
    public Builder() {}

    
Associates key with value in the built bimap. Duplicate keys or values are not allowed, and will cause build() to fail.
    @Override public Builder<K, V> put(K key, V value) {
      super.put(keyvalue);
      return this;
    }

    
Associates all of the given map's keys and values in the built bimap. Duplicate keys or values are not allowed, and will cause build() to fail.

Throws:
java.lang.NullPointerException if any key or value in map is null
    @Override public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
      super.putAll(map);
      return this;
    }

    
Returns a newly-created immutable bimap.

Throws:
java.lang.IllegalArgumentException if duplicate keys or values were added
    @Override public ImmutableBiMap<K, V> build() {
      ImmutableMap<K, V> map = super.build();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(map);
    }
  }

  
Returns an immutable bimap containing the same entries as map. If map somehow contains entries with duplicate keys (for example, if it is a SortedMap whose comparator is not consistent with equals), the results of this method are undefined.

Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.

Throws:
java.lang.IllegalArgumentException if two keys have the same value
java.lang.NullPointerException if any key or value in map is null
  public static <K, V> ImmutableBiMap<K, V> copyOf(
      Map<? extends K, ? extends V> map) {
    if (map instanceof ImmutableBiMap) {
      @SuppressWarnings("unchecked"// safe since map is not writable
      ImmutableBiMap<K, V> bimap = (ImmutableBiMap<K, V>) map;
      // TODO(user): if we need to make a copy of a BiMap because the
      // forward map is a view, don't make a copy of the non-view delegate map
      if (!bimap.isPartialView()) {
        return bimap;
      }
    }
    if (map.isEmpty()) {
      return of();
    }
    ImmutableMap<K, V> immutableMap = ImmutableMap.copyOf(map);
    return new RegularImmutableBiMap<K, V>(immutableMap);
  }
  abstract ImmutableMap<K, V> delegate();

  

The inverse of an ImmutableBiMap is another ImmutableBiMap.

  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);
  }
    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.
  @Override public ImmutableSet<V> values() {
    return inverse().keySet();
  }

  
Guaranteed to throw an exception and leave the bimap unmodified.

  public V forcePut(K key, V value) {
    throw new UnsupportedOperationException();
  }
  @Override public boolean isEmpty() {
    return delegate().isEmpty();
  }
  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();
  }

  
Serialized type for all ImmutableBiMap instances. It captures the logical contents and they are reconstructed using public factory methods. This ensures that the implementation types remain as implementation details. Since the bimap is immutable, ImmutableBiMap doesn't require special logic for keeping the bimap and its inverse in sync during serialization, the way AbstractBiMap does.
  private static class SerializedForm extends ImmutableMap.SerializedForm {
    SerializedForm(ImmutableBiMap<?, ?> bimap) {
      super(bimap);
    }
      Builder<ObjectObjectbuilder = new Builder<ObjectObject>();
      return createMap(builder);
    }
    private static final long serialVersionUID = 0;
  }
    return new SerializedForm(this);
  }
New to GrepCode? Check out our FAQ X