Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2010 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.testing;
 
 import java.util.Map;
 import java.util.Set;
A wrapper around TreeMap that aggressively checks to see if keys are mutually comparable. This implementation passes the navigable map test suites.

Author(s):
Louis Wasserman
 
 public final class SafeTreeMap<K, V> implements SerializableSortedMap<K, V> {
   @SuppressWarnings("unchecked")
   private static final Comparator<ObjectNATURAL_ORDER = new Comparator<Object>() {
     @Override public int compare(Object o1Object o2) {
       return ((Comparable<Object>) o1).compareTo(o2);
     }
   };
   private final SortedMap<K, V> delegate;
 
   public SafeTreeMap() {
     this(new TreeMap<K, V>());
   }
 
   public SafeTreeMap(Comparator<? super K> comparator) {
     this(new TreeMap<K, V>(comparator));
   }
 
   public SafeTreeMap(Map<? extends K, ? extends V> map) {
     this(new TreeMap<K, V>(map));
   }
 
   private SafeTreeMap(SortedMap<K, V> delegate) {
     this. = delegate;
     if (delegate == null) {
       throw new NullPointerException();
     }
     for (K k : keySet()) {
       checkValid(k);
     }
   }
 
   @Override public void clear() {
     .clear();
   }
 
   @SuppressWarnings("unchecked")
   @Override public Comparator<? super K> comparator() {
     Comparator<? super K> comparator = .comparator();
     if (comparator == null) {
       comparator = (Comparator<? super K>) ;
     }
     return comparator;
   }
 
   @Override public boolean containsKey(Object key) {
     try {
       return .containsKey(checkValid(key));
     } catch (NullPointerException e) {
       return false;
     } catch (ClassCastException e) {
       return false;
     }
   }
 
   @Override public boolean containsValue(Object value) {
     return .containsValue(value);
   }
 
   @Override public Set<Entry<K, V>> entrySet() {
     return new AbstractSet<Entry<K, V>>() {
       private Set<Entry<K, V>> delegate() {
         return .entrySet();
       }
 
      @Override
      public boolean contains(Object object) {
        try {
          return delegate().contains(object);
        } catch (NullPointerException e) {
          return false;
        } catch (ClassCastException e) {
          return false;
        }
      }
      @Override
      public Iterator<Entry<K, V>> iterator() {
        return delegate().iterator();
      }
      @Override
      public int size() {
        return delegate().size();
      }
      @Override
      public boolean remove(Object o) {
        return delegate().remove(o);
      }
      @Override
      public void clear() {
        delegate().clear();
      }
    };
  }
  @Override public K firstKey() {
    return .firstKey();
  }
  @Override public V get(Object key) {
    return .get(checkValid(key));
  }
  @Override public SortedMap<K, V> headMap(K toKey) {
    return new SafeTreeMap<K, V>(.headMap(checkValid(toKey)));
  }
  @Override public boolean isEmpty() {
    return .isEmpty();
  }
  @Override public Set<K> keySet() {
    return .keySet();
  }
  @Override public K lastKey() {
    return .lastKey();
  }
  @Override public V put(K key, V value) {
    return .put(checkValid(key), value);
  }
  @Override public void putAll(Map<? extends K, ? extends V> map) {
    for (K key : map.keySet()) {
      checkValid(key);
    }
    .putAll(map);
  }
  @Override public V remove(Object key) {
    return .remove(checkValid(key));
  }
  @Override public int size() {
    return .size();
  }
  @Override public SortedMap<K, V> subMap(K fromKey, K toKey) {
    return new SafeTreeMap<K, V>(.subMap(checkValid(fromKey), checkValid(toKey)));
  }
  @Override public SortedMap<K, V> tailMap(K fromKey) {
    return new SafeTreeMap<K, V>(.tailMap(checkValid(fromKey)));
  }
  @Override public Collection<V> values() {
    return .values();
  }
  private <T> T checkValid(T t) {
    // a ClassCastException is what's supposed to happen!
    @SuppressWarnings("unchecked")
    K k = (K) t;
    comparator().compare(kk);
    return t;
  }
  @Override public boolean equals(Object obj) {
    return .equals(obj);
  }
  @Override public int hashCode() {
    return .hashCode();
  }
  @Override public String toString() {
    return .toString();
  }
  private static final long serialVersionUID = 0L;
New to GrepCode? Check out our FAQ X