Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2008 Mozilla Foundation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a 
   * copy of this software and associated documentation files (the "Software"), 
   * to deal in the Software without restriction, including without limitation 
   * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
   * and/or sell copies of the Software, and to permit persons to whom the 
   * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in 
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
  * DEALINGS IN THE SOFTWARE.
  */
 
 package nu.validator.collections;
 
 
 public final class HeadBiasedSortedSet<E> extends AbstractSet<E> implements
         SortedSet<E> {
 
     private final class Node<F> {
         public final F value;
 
         public Node<F> next;

        

Parameters:
value
next
 
         public Node(F valueNode<F> next) {
             this. = value;
             this. = next;
         }
     }
 
     private final class IteratorImpl implements Iterator<E> {
 
         private Node<E> next;

        

Parameters:
next
 
         IteratorImpl(Node<E> head) {
             this. = head;
         }
 
         public boolean hasNext() {
             return  != null;
         }
 
         public E next() {
             if ( == null) {
                 throw new NoSuchElementException();
             }
             E rv = .;
              = .;
             return rv;
         }
 
         public void remove() {
             throw new UnsupportedOperationException();
         }
 
     }
 
     private final Comparator<? super E> comparator;
 
     private final Node<E> head = new Node<E>(nullnull);
 
     private int size = 0;

    

Parameters:
comparator
 
     public HeadBiasedSortedSet(Comparator<? super E> comparator) {
         this. = comparator;
     }
 
     public HeadBiasedSortedSet() {
         this. = null;
     }
 
     public HeadBiasedSortedSet(SortedSet<E> set) {
         this. = set.comparator();
         // XXX this is very inefficient
        for (E e : set) {
            this.add(e);
        }
    }
    public HeadBiasedSortedSet(Collection<? extends E> collection) {
        this. = null;
        // XXX this is very inefficient
        for (E e : collection) {
            this.add(e);
        }
    }
    
    public Comparator<? super E> comparator() {
        return ;
    }
    @Override
    public Iterator<E> iterator() {
        return new IteratorImpl(.);
    }
    @Override
    public int size() {
        return ;
    }
    public E first() {
        Node<E> first = .;
        if (first == null) {
            throw new NoSuchElementException();
        } else {
            return first.value;
        }
    }
    public SortedSet<E> headSet(E toElement) {
        throw new UnsupportedOperationException();
    }
    public E last() {
        Node<E> first = .;
        if (first == null) {
            throw new NoSuchElementException();
        } else {
            Node<E> prev = first;
            while(prev.next != null) {
                prev = prev.next;
            }
            return prev.value;
        }
    }
    public SortedSet<E> subSet(E fromElement, E toElement) {
        throw new UnsupportedOperationException();
    }
    public SortedSet<E> tailSet(E fromElement) {
        throw new UnsupportedOperationException();
    }

    
    @Override
    public boolean add(E o) {
        Node<E> prev = ;
        while (prev.next != null) {
            int comp = compare(oprev.next.value);
            if (comp < 0) {
                prev.next = new Node<E>(oprev.next);
                ++;
                return true;
            } else if (comp == 0) {
                return false;
            }
            prev = prev.next;
        }
        // if we haven't returned yet, this is greater than
        prev.next = new Node<E>(onull);
        ++;
        return true;
    }
    private int compare(E one, E other) {
        if ( == null) {
            return ((Comparable<E>) one).compareTo(other);
        } else {
            return .compare(oneother);
        }
    }

    
    @Override
    public void clear() {
         = 0;
        . = null;
    }
New to GrepCode? Check out our FAQ X