CursorableSubList(CursorableLinkedList list,
    int from,
    int to) 
{
        if(0  > from || list.size() <  to) {
            throw new IndexOutOfBoundsException();
        } else if(from  > to) {
            throw new IllegalArgumentException();
        }
        _list = list;
        if(from <  list.size()) {
            _head.setNext(_list.getListableAt(from));
            _pre = (null == _head.next()) ? null : _head.next().prev();
        } else {
            _pre = _list.getListableAt(from-1);
        }
        if(from == to) {
            _head.setNext(null);
            _head.setPrev(null);
            if(to <  list.size()) {
                _post = _list.getListableAt(to);
            } else {
                _post = null;
            }
        } else {
            _head.setPrev(_list.getListableAt(to-1));
            _post = _head.prev().next();
        }
        _size = to - from;
        _modCount = _list._modCount;
}

 public boolean add(Object o) 
{
        checkForComod();
        return super.add(o);
}

 public  void add(int index,
    Object element) 
{
        checkForComod();
        super.add(index,element);
}

 public boolean addAll(Collection c) 
{
        checkForComod();
        return super.addAll(c);
}

 public boolean addAll(int index,
    Collection c) 
{
        checkForComod();
        return super.addAll(index,c);
}

 public boolean addFirst(Object o) 
{
        checkForComod();
        return super.addFirst(o);
}

 public boolean addLast(Object o) 
{
        checkForComod();
        return super.addLast(o);
}

 protected  void checkForComod() throws ConcurrentModificationException 
{
        if(_modCount != _list._modCount) {
            throw new ConcurrentModificationException();
        }
}

Test to see if my underlying list has been modified by some other process. If it has, throws a ConcurrentModificationException , otherwise quietly returns.

 public  void clear() 
{
        checkForComod();
        Iterator it = iterator();
        while(it.hasNext()) {
            it.next();
            it.remove();
        }
}

 public boolean contains(Object o) 
{
        checkForComod();
        return super.contains(o);
}

 public boolean containsAll(Collection c) 
{
        checkForComod();
        return super.containsAll(c);
}

 public boolean equals(Object o) 
{
        checkForComod();
        return super.equals(o);
}

 public Object get(int index) 
{
        checkForComod();
        return super.get(index);
}

 public Object getFirst() 
{
        checkForComod();
        return super.getFirst();
}

 public Object getLast() 
{
        checkForComod();
        return super.getLast();
}

 public int hashCode() 
{
        checkForComod();
        return super.hashCode();
}

 public int indexOf(Object o) 
{
        checkForComod();
        return super.indexOf(o);
}

 protected Listable insertListable(Listable before,
    Listable after,
    Object value) 
{
        _modCount++;
        _size++;
        Listable elt = _list.insertListable((null == before ? _pre : before), (null == after ? _post : after),value);
        if(null == _head.next()) {
            _head.setNext(elt);
            _head.setPrev(elt);
        }
        if(before == _head.prev()) {
            _head.setPrev(elt);
        }
        if(after == _head.next()) {
            _head.setNext(elt);
        }
        broadcastListableInserted(elt);
        return elt;
}

Inserts a new value into my list, after the specified before element, and before the specified after element

 public boolean isEmpty() 
{
        checkForComod();
        return super.isEmpty();
}

 public Iterator iterator() 
{
        checkForComod();
        return super.iterator();
}

 public int lastIndexOf(Object o) 
{
        checkForComod();
        return super.lastIndexOf(o);
}

 public ListIterator listIterator() 
{
        checkForComod();
        return super.listIterator();
}

 public ListIterator listIterator(int index) 
{
        checkForComod();
        return super.listIterator(index);
}

 public boolean remove(Object o) 
{
        checkForComod();
        return super.remove(o);
}

 public Object remove(int index) 
{
        checkForComod();
        return super.remove(index);
}

 public boolean removeAll(Collection c) 
{
        checkForComod();
        return super.removeAll(c);
}

 public Object removeFirst() 
{
        checkForComod();
        return super.removeFirst();
}

 public Object removeLast() 
{
        checkForComod();
        return super.removeLast();
}

 protected  void removeListable(Listable elt) 
{
        _modCount++;
        _size--;
        if(_head.next() == elt && _head.prev() == elt) {
            _head.setNext(null);
            _head.setPrev(null);
        }
        if(_head.next() == elt) {
            _head.setNext(elt.next());
        }
        if(_head.prev() == elt) {
            _head.setPrev(elt.prev());
        }
        _list.removeListable(elt);
        broadcastListableRemoved(elt);
}

Removes the given CursorableLinkedList.Listable from my list.

 public boolean retainAll(Collection c) 
{
        checkForComod();
        return super.retainAll(c);
}

 public Object set(int index,
    Object element) 
{
        checkForComod();
        return super.set(index,element);
}

 public int size() 
{
        checkForComod();
        return super.size();
}

 public List subList(int fromIndex,
    int toIndex) 
{
        checkForComod();
        return super.subList(fromIndex,toIndex);
}

 public Object[] toArray() 
{
        checkForComod();
        return super.toArray();
}

 public Object[] toArray(Object[] a) 
{
        checkForComod();
        return super.toArray(a);
}