Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.checkArgument;
 
 
 
 import  javax.annotation.Nullable;

Implementation of ImmutableMap backed by a non-empty java.util.EnumMap.

Author(s):
Louis Wasserman
 
 @GwtCompatible(serializable = true, emulated = true)
 @SuppressWarnings("serial"// we're overriding default serialization
 final class ImmutableEnumMap<K extends Enum<K>, V> extends ImmutableMap<K, V> {
   static <K extends Enum<K>, V> ImmutableMap<K, V> asImmutable(EnumMap<K, V> map) {
     switch (map.size()) {
       case 0:
         return ImmutableMap.of();
       case 1: {
         Entry<K, V> entry = Iterables.getOnlyElement(map.entrySet());
         return ImmutableMap.of(entry.getKey(), entry.getValue());
       }
       default:
         return new ImmutableEnumMap<K, V>(map);
     }
   }
 
   private transient final EnumMap<K, V> delegate;
 
   private ImmutableEnumMap(EnumMap<K, V> delegate) {
     this. = delegate;
     checkArgument(!delegate.isEmpty());
   }
 
   @Override
     return new ImmutableSet<K>() {
 
       @Override
       public boolean contains(Object object) {
         return .containsKey(object);
       }
 
       @Override
       public int size() {
         return ImmutableEnumMap.this.size();
       }
 
       @Override
       public UnmodifiableIterator<K> iterator() {
         return Iterators.unmodifiableIterator(.keySet().iterator());
       }
 
       @Override
       boolean isPartialView() {
         return true;
       }
     };
   }
 
   @Override
   public int size() {
     return .size();
   }
 
   @Override
   public boolean containsKey(@Nullable Object key) {
     return .containsKey(key);
   }
 
   @Override
   public V get(Object key) {
     return .get(key);
   }
 
   @Override
   ImmutableSet<Entry<K, V>> createEntrySet() {
    return new ImmutableMapEntrySet<K, V>() {
      @Override
      ImmutableMap<K, V> map() {
        return ImmutableEnumMap.this;
      }
      @Override
      public UnmodifiableIterator<Entry<K, V>> iterator() {
        return new UnmodifiableIterator<Entry<K, V>>() {
          private final Iterator<Entry<K, V>> backingIterator = .entrySet().iterator();
          @Override
          public boolean hasNext() {
            return .hasNext();
          }
          @Override
          public Entry<K, V> next() {
            Entry<K, V> entry = .next();
            return Maps.immutableEntry(entry.getKey(), entry.getValue());
          }
        };
      }
    };
  }
  boolean isPartialView() {
    return false;
  }
  // All callers of the constructor are restricted to <K extends Enum<K>>.
    return new EnumSerializedForm<K, V>();
  }
  /*
   * This class is used to serialize ImmutableEnumSet instances.
   */
  private static class EnumSerializedForm<K extends Enum<K>, V>
      implements Serializable {
    final EnumMap<K, V> delegate;
    EnumSerializedForm(EnumMap<K, V> delegate) {
      this. = delegate;
    }
    Object readResolve() {
      return new ImmutableEnumMap<K, V>();
    }
    private static final long serialVersionUID = 0;
  }
New to GrepCode? Check out our FAQ X