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;
 
A wrapper around TreeSet that aggressively checks to see if elements are mutually comparable. This implementation passes the navigable set test suites.

Author(s):
Louis Wasserman
 
 public final class SafeTreeSet<E> implements SerializableSortedSet<E> {
   @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 SortedSet<E> delegate;
 
   public SafeTreeSet() {
     this(new TreeSet<E>());
   }
 
   public SafeTreeSet(Collection<? extends E> collection) {
     this(new TreeSet<E>(collection));
   }
 
   public SafeTreeSet(Comparator<? super E> comparator) {
     this(new TreeSet<E>(comparator));
   }
 
   private SafeTreeSet(SortedSet<E> delegate) {
     this. = delegate;
     for (E e : this) {
       checkValid(e);
     }
   }
 
   @Override public boolean add(E element) {
     return .add(checkValid(element));
   }
 
   @Override public boolean addAll(Collection<? extends E> collection) {
     for (E e : collection) {
       checkValid(e);
     }
     return .addAll(collection);
   }
 
   @Override public void clear() {
     .clear();
   }
 
   @SuppressWarnings("unchecked")
   @Override public Comparator<? super E> comparator() {
     Comparator<? super E> comparator = .comparator();
     if (comparator == null) {
       comparator = (Comparator<? super E>) ;
     }
     return comparator;
   }
 
   @Override public boolean contains(Object object) {
     return .contains(checkValid(object));
   }
 
   @Override public boolean containsAll(Collection<?> c) {
     return .containsAll(c);
   }
 
   @Override public E first() {
     return .first();
   }
 
   @Override public SortedSet<E> headSet(E toElement) {
     return new SafeTreeSet<E>(.headSet(checkValid(toElement)));
   }
  @Override public boolean isEmpty() {
    return .isEmpty();
  }
  @Override public Iterator<E> iterator() {
    return .iterator();
  }
  @Override public E last() {
    return .last();
  }
  @Override public boolean remove(Object object) {
    return .remove(checkValid(object));
  }
  @Override public boolean removeAll(Collection<?> c) {
    return .removeAll(c);
  }
  @Override public boolean retainAll(Collection<?> c) {
    return .retainAll(c);
  }
  @Override public int size() {
    return .size();
  }
  @Override public SortedSet<E> subSet(E fromElement, E toElement) {
    return new SafeTreeSet<E>(.subSet(checkValid(fromElement), checkValid(toElement)));
  }
  @Override public SortedSet<E> tailSet(E fromElement) {
    return new SafeTreeSet<E>(.tailSet(checkValid(fromElement)));
  }
  @Override public Object[] toArray() {
    return .toArray();
  }
  @Override public <T> T[] toArray(T[] a) {
    return .toArray(a);
  }
  private <T> T checkValid(T t) {
    // a ClassCastException is what's supposed to happen!
    @SuppressWarnings("unchecked")
    E e = (E) t;
    comparator().compare(ee);
    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