ListIter(int index) 
{
          
            if(index == 0) {
                _cur = new Listable(null,_head.next(),null);
                _nextIndex = 0;
            } else if(index == _size) {
                _cur = new Listable(_head.prev(),null,null);
                _nextIndex = _size;
            } else {
                Listable temp = getListableAt(index);
                _cur = new Listable(temp.prev(),temp,null);
                _nextIndex = index;
            }
}

 public  void add(Object o) 
{
            checkForComod();
            _cur.setPrev(insertListable(_cur.prev(),_cur.next(),o));
            _lastReturned = null;
            _nextIndex++;
            _expectedModCount++;
}

 protected  void checkForComod() 
{
            if(_expectedModCount != _modCount) {
                throw new ConcurrentModificationException();
            }
}

 public boolean hasNext() 
{
            checkForComod();
            return(null != _cur.next() && _cur.prev() != _head.prev());
}

 public boolean hasPrevious() 
{
            checkForComod();
            return(null != _cur.prev() && _cur.next() != _head.next());
}

 public Object next() 
{
            checkForComod();
            if(!hasNext()) {
                throw new NoSuchElementException();
            } else {
                Object ret = _cur.next().value();
                _lastReturned = _cur.next();
                _cur.setPrev(_cur.next());
                _cur.setNext(_cur.next().next());
                _nextIndex++;
                return ret;
            }
}

 public int nextIndex() 
{
            checkForComod();
            if(!hasNext()) {
                return size();
            }
            return _nextIndex;
}

 public Object previous() 
{
            checkForComod();
            if(!hasPrevious()) {
                throw new NoSuchElementException();
            } else {
                Object ret = _cur.prev().value();
                _lastReturned = _cur.prev();
                _cur.setNext(_cur.prev());
                _cur.setPrev(_cur.prev().prev());
                _nextIndex--;
                return ret;
            }
}

 public int previousIndex() 
{
            checkForComod();
            if(!hasPrevious()) {
                return -1;
            }
            return _nextIndex-1;
}

 public  void remove() 
{
            checkForComod();
            if(null == _lastReturned) {
                throw new IllegalStateException();
            } else {
                _cur.setNext(_lastReturned == _head.prev() ? null : _lastReturned.next());
                _cur.setPrev(_lastReturned == _head.next() ? null : _lastReturned.prev());
                removeListable(_lastReturned);
                _lastReturned = null;
                _nextIndex--;
                _expectedModCount++;
            }
}

 public  void set(Object o) 
{
            checkForComod();
            try {
                _lastReturned.setValue(o);
            } catch(NullPointerException e) {
                throw new IllegalStateException();
            }
}