Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 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 static com.google.common.collect.CollectPreconditions.checkEntryNotNull;
 import static com.google.common.collect.Iterables.getOnlyElement;
 
 import java.util.List;
 import java.util.Map;
 
GWT emulation of ImmutableMap. For non sorted maps, it is a thin wrapper around java.util.Collections.emptyMap(), java.util.Collections.singletonMap(java.lang.Object,java.lang.Object) and java.util.LinkedHashMap for empty, singleton and regular maps respectively. For sorted maps, it's a thin wrapper around java.util.TreeMap.

Author(s):
Hayward Chan
See also:
ImmutableSortedMap
 
 public abstract class ImmutableMap<K, V> implements Map<K, V>, Serializable {
 
   ImmutableMap() {}
 
   public static <K, V> ImmutableMap<K, V> of() {
     return ImmutableBiMap.of();
   }
 
   public static <K, V> ImmutableMap<K, V> of(K k1, V v1) {
     return ImmutableBiMap.of(k1v1);
   }
 
   public static <K, V> ImmutableMap<K, V> of(K k1, V v1, K k2, V v2) {
     return new RegularImmutableMap<K, V>(entryOf(k1v1), entryOf(k2v2));
   }
 
   public static <K, V> ImmutableMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3) {
     return new RegularImmutableMap<K, V>(
         entryOf(k1v1), entryOf(k2v2), entryOf(k3v3));
   }
 
   public static <K, V> ImmutableMap<K, V> of(
       K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
     return new RegularImmutableMap<K, V>(
         entryOf(k1v1), entryOf(k2v2), entryOf(k3v3), entryOf(k4v4));
   }
 
   public static <K, V> ImmutableMap<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 RegularImmutableMap<K, V>(entryOf(k1v1),
         entryOf(k2v2), entryOf(k3v3), entryOf(k4v4), entryOf(k5v5));
   }
 
   // looking for of() with > 5 entries? Use the builder instead.
 
   public static <K, V> Builder<K, V> builder() {
     return new Builder<K, V>();
   }
 
   static <K, V> Entry<K, V> entryOf(K key, V value) {
     checkEntryNotNull(keyvalue);
     return Maps.immutableEntry(keyvalue);
   }
 
   public static class Builder<K, V> {
     final List<Entry<K, V>> entries = Lists.newArrayList();
 
     public Builder() {}
 
     public Builder<K, V> put(K key, V value) {
       .add(entryOf(keyvalue));
       return this;
     }
 
     public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
       if (entry instanceof ImmutableEntry) {
        checkNotNull(entry.getKey());
        checkNotNull(entry.getValue());
        @SuppressWarnings("unchecked"// all supported methods are covariant
        Entry<K, V> immutableEntry = (Entry<K, V>) entry;
        .add(immutableEntry);
      } else {
        .add(entryOf((K) entry.getKey(), (V) entry.getValue()));
      }
      return this;
    }
    public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
      for (Entry<? extends K, ? extends V> entry : map.entrySet()) {
        put(entry.getKey(), entry.getValue());
      }
      return this;
    }
    public ImmutableMap<K, V> build() {
      return fromEntryList();
    }
    private static <K, V> ImmutableMap<K, V> fromEntryList(
        List<Entry<K, V>> entries) {
      int size = entries.size();
      switch (size) {
        case 0:
          return of();
        case 1:
          Entry<K, V> entry = getOnlyElement(entries);
          return of(entry.getKey(), entry.getValue());
        default:
          @SuppressWarnings("unchecked")
          Entry<K, V>[] entryArray
              = entries.toArray(new Entry[entries.size()]);
          return new RegularImmutableMap<K, V>(entryArray);
      }
    }
  }
  public static <K, V> ImmutableMap<K, V> copyOf(
      Map<? extends K, ? extends V> map) {
    if ((map instanceof ImmutableMap) && !(map instanceof ImmutableSortedMap)) {
      @SuppressWarnings("unchecked"// safe since map is not writable
      ImmutableMap<K, V> kvMap = (ImmutableMap<K, V>) map;
      return kvMap;
    } else if (map instanceof EnumMap) {
      EnumMap<?, ?> enumMap = (EnumMap<?, ?>) map;
      for (Map.Entry<?, ?> entry : enumMap.entrySet()) {
        checkNotNull(entry.getKey());
        checkNotNull(entry.getValue());
      }
      @SuppressWarnings("unchecked")
      // immutable collections are safe for covariant casts
      ImmutableMap<K, V> result = ImmutableEnumMap.asImmutable(new EnumMap(enumMap));
      return result;
    }
    int size = map.size();
    switch (size) {
      case 0:
        return of();
      case 1:
        Entry<? extends K, ? extends V> entry
            = getOnlyElement(map.entrySet());
        return ImmutableMap.<K, V>of(entry.getKey(), entry.getValue());
      default:
        Map<K, V> orderPreservingCopy = Maps.newLinkedHashMap();
        for (Entry<? extends K, ? extends V> e : map.entrySet()) {
          orderPreservingCopy.put(
              checkNotNull(e.getKey()), checkNotNull(e.getValue()));
        }
        return new RegularImmutableMap<K, V>(orderPreservingCopy);
    }
  }
  abstract boolean isPartialView();
  public final V put(K k, V v) {
    throw new UnsupportedOperationException();
  }
  public final V remove(Object o) {
    throw new UnsupportedOperationException();
  }
  public final void putAll(Map<? extends K, ? extends V> map) {
    throw new UnsupportedOperationException();
  }
  public final void clear() {
    throw new UnsupportedOperationException();
  }
  public boolean isEmpty() {
    return size() == 0;
  }
  public boolean containsKey(@Nullable Object key) {
    return get(key) != null;
  }
  public boolean containsValue(@Nullable Object value) {
    return values().contains(value);
  }
  private transient ImmutableSet<Entry<K, V>> cachedEntrySet = null;
  public final ImmutableSet<Entry<K, V>> entrySet() {
    if ( != null) {
      return ;
    }
    return  = createEntrySet();
  }
  abstract ImmutableSet<Entry<K, V>> createEntrySet();
  private transient ImmutableSet<K> cachedKeySet = null;
  public ImmutableSet<K> keySet() {
    if ( != null) {
      return ;
    }
    return  = createKeySet();
  }
    return new ImmutableMapKeySet<K, V>(this);
  }
  private transient ImmutableCollection<V> cachedValues = null;
  public ImmutableCollection<V> values() {
    if ( != null) {
      return ;
    }
    return  = createValues();
  }
  // esnickell is editing here
  // cached so that this.multimapView().inverse() only computes inverse once
  private transient ImmutableSetMultimap<K, V> multimapView;
  public ImmutableSetMultimap<K, V> asMultimap() {
    ImmutableSetMultimap<K, V> result = ;
    return (result == null) ? ( = createMultimapView()) : result;
  }
    return new ImmutableSetMultimap<K, V>(mapmap.size(), null);
  }
    final Map<K, V> outer = this;
    return new ImmutableMap<K, ImmutableSet<V>>() {
      @Override
      public int size() {
        return outer.size();
      }
      @Override
      public ImmutableSet<V> get(@Nullable Object key) {
        V outerValue = outer.get(key);
        return outerValue == null ? null : ImmutableSet.of(outerValue);
      }
      @Override
        return new ImmutableSet<Entry<K, ImmutableSet<V>>>() {
          @Override
          public UnmodifiableIterator<Entry<K, ImmutableSet<V>>> iterator() {
            final Iterator<Entry<K,V>> outerEntryIterator = outer.entrySet().iterator();
            return new UnmodifiableIterator<Entry<K, ImmutableSet<V>>>() {
              @Override
              public boolean hasNext() {
                return outerEntryIterator.hasNext();
              }
              @Override
              public Entry<K, ImmutableSet<V>> next() {
                final Entry<K, V> outerEntry = outerEntryIterator.next();
                return new AbstractMapEntry<K, ImmutableSet<V>>() {
                  @Override
                  public K getKey() {
                    return outerEntry.getKey();
                  }
                  @Override
                  public ImmutableSet<V> getValue() {
                    return ImmutableSet.of(outerEntry.getValue());
                  }
                };
              }
            };
          }
          @Override
          boolean isPartialView() {
            return false;
          }
          @Override
          public int size() {
            return outer.size();
          }
        };
      }
      @Override
      boolean isPartialView() {
        return false;
      }
    };
  }
    return new ImmutableMapValues<K, V>(this);
  }
  @Override public boolean equals(@Nullable Object object) {
    return Maps.equalsImpl(thisobject);
  }
  @Override public int hashCode() {
    // not caching hash code since it could change if map values are mutable
    // in a way that modifies their hash codes
    return entrySet().hashCode();
  }
  @Override public String toString() {
    return Maps.toStringImpl(this);
  }
New to GrepCode? Check out our FAQ X