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 java.util.Map;
 import java.util.Set;
 
GWT implementation of ImmutableMap that forwards to another map.

Author(s):
Hayward Chan
 
 public abstract class ForwardingImmutableMap<K, V> extends ImmutableMap<K, V> {
 
   final transient Map<K, V> delegate;
 
   ForwardingImmutableMap(Map<? extends K, ? extends V> delegate) {
     this. = Collections.unmodifiableMap(delegate);
   }
 
   @SuppressWarnings("unchecked")
   ForwardingImmutableMap(Entry<? extends K, ? extends V>... entries) {
     Map<K, V> delegate = Maps.newLinkedHashMap();
     for (Entry<? extends K, ? extends V> entry : entries) {
       K key = checkNotNull(entry.getKey());
       V previous = delegate.put(keycheckNotNull(entry.getValue()));
       if (previous != null) {
         throw new IllegalArgumentException("duplicate key: " + key);
       }
     }
     this. = Collections.unmodifiableMap(delegate);
   }
 
   boolean isPartialView() {
     return false;
   }
 
   public final boolean isEmpty() {
     return .isEmpty();
   }
 
   public final boolean containsKey(@Nullable Object key) {
     return Maps.safeContainsKey(key);
   }
 
   public final boolean containsValue(@Nullable Object value) {
     return .containsValue(value);
   }
 
   public V get(@Nullable Object key) {
     return (key == null) ? null : Maps.safeGet(key);
   }
 
     return ImmutableSet.unsafeDelegate(
         new ForwardingSet<Entry<K, V>>() {
           @Override protected Set<Entry<K, V>> delegate() {
             return .entrySet();
           }
           @Override public boolean contains(Object object) {
             if (object instanceof Entry<?, ?>
                 && ((Entry<?, ?>) object).getKey() == null) {
               return false;
             }
             try {
               return super.contains(object);
             } catch (ClassCastException e) {
               return false;
             }
           }
           @Override public <T> T[] toArray(T[] array) {
             T[] result = super.toArray(array);
             if (size() < result.length) {
               // It works around a GWT bug where elements after last is not
               // properly null'ed.
               result[size()] = null;
             }
             return result;
           }
         });
  }
    return ImmutableSet.unsafeDelegate(.keySet());
  }
    return ImmutableCollection.unsafeDelegate(.values());
  }
  @Override public int size() {
    return .size();
  }
  @Override public boolean equals(@Nullable Object object) {
    return .equals(object);
  }
  @Override public int hashCode() {
    return .hashCode();
  }
  @Override public String toString() {
    return .toString();
  }
New to GrepCode? Check out our FAQ X