public CursorableLinkedList() 
{
    //-----------------------------------------------------------------------
        super();
        init(); // must call init() as use super();
}

Constructor that creates.

 public CursorableLinkedList(Collection coll) 
{
        super(coll);
}

Constructor that copies the specified collection

Parameters:

coll - the collection to copy

 protected  void addNode(Node nodeToInsert,
    Node insertBeforeNode) 
{
        super.addNode(nodeToInsert, insertBeforeNode);
        broadcastNodeInserted(nodeToInsert);
}

Inserts a new node into the list.

 protected  void broadcastNodeChanged(Node node) 
{
        Iterator it = cursors.iterator();
        while (it.hasNext()) {
            WeakReference ref = (WeakReference) it.next();
            Cursor cursor = (Cursor) ref.get();
            if (cursor == null) {
                it.remove(); // clean up list
            } else {
                cursor.nodeChanged(node);
            }
        }
}

Informs all of my registered cursors that the specified element was changed.

 protected  void broadcastNodeInserted(Node node) 
{
        Iterator it = cursors.iterator();
        while (it.hasNext()) {
            WeakReference ref = (WeakReference) it.next();
            Cursor cursor = (Cursor) ref.get();
            if (cursor == null) {
                it.remove(); // clean up list
            } else {
                cursor.nodeInserted(node);
            }
        }
}

Informs all of my registered cursors that the specified element was just added to my list.

 protected  void broadcastNodeRemoved(Node node) 
{
        Iterator it = cursors.iterator();
        while (it.hasNext()) {
            WeakReference ref = (WeakReference) it.next();
            Cursor cursor = (Cursor) ref.get();
            if (cursor == null) {
                it.remove(); // clean up list
            } else {
                cursor.nodeRemoved(node);
            }
        }
}

Informs all of my registered cursors that the specified element was just removed from my list.

 protected ListIterator createSubListListIterator(LinkedSubList subList,
    int fromIndex) 
{
        SubCursor cursor = new SubCursor(subList, fromIndex);
        registerCursor(cursor);
        return cursor;
}

Creates a list iterator for the sublist.

 public CursorableLinkedList.Cursor cursor() 
{
        return cursor(0);
}

Returns a Cursor for iterating through the elements of this list.

A Cursor is a ListIterator with an additional close() method. Calling this method immediately discards the references to the cursor. If it is not called, then the garbage collector will still remove the reference as it is held via a WeakReference.

The cursor enables iteration and list changes to occur in any order without invalidating the iterator (from one thread). When elements are added to the list, an event is fired to all active cursors enabling them to adjust to the change in the list.

When the "current" (i.e., last returned by ListIterator#next or ListIterator#previous ) element of the list is removed, the cursor automatically adjusts to the change (invalidating the last returned value such that it cannot be removed).

The #listIterator() method returns the same as this method, and can be cast to a Cursor if the close method is required.

 public CursorableLinkedList.Cursor cursor(int fromIndex) 
{
        Cursor cursor = new Cursor(this, fromIndex);
        registerCursor(cursor);
        return cursor;
}

Returns a Cursor for iterating through the elements of this list starting from a specified index.

A Cursor is a ListIterator with an additional close() method. Calling this method immediately discards the references to the cursor. If it is not called, then the garbage collector will still remove the reference as it is held via a WeakReference.

The cursor enables iteration and list changes to occur in any order without invalidating the iterator (from one thread). When elements are added to the list, an event is fired to all active cursors enabling them to adjust to the change in the list.

When the "current" (i.e., last returned by ListIterator#next or ListIterator#previous ) element of the list is removed, the cursor automatically adjusts to the change (invalidating the last returned value such that it cannot be removed).

The #listIterator(int) method returns the same as this method, and can be cast to a Cursor if the close method is required.

 protected  void init() 
{
        super.init();
        cursors = new ArrayList();
}

The equivalent of a default constructor called by any constructor and by readObject.

 public Iterator iterator() 
{
        return super.listIterator(0);
}

Returns an iterator that does not support concurrent modification.

If the underlying list is modified while iterating using this iterator a ConcurrentModificationException will occur. The cursor behaviour is available via #listIterator() .

 public ListIterator listIterator() 
{
        return cursor(0);
}

Returns a cursor iterator that allows changes to the underlying list in parallel.

The cursor enables iteration and list changes to occur in any order without invalidating the iterator (from one thread). When elements are added to the list, an event is fired to all active cursors enabling them to adjust to the change in the list.

When the "current" (i.e., last returned by ListIterator#next or ListIterator#previous ) element of the list is removed, the cursor automatically adjusts to the change (invalidating the last returned value such that it cannot be removed).

 public ListIterator listIterator(int fromIndex) 
{
        return cursor(fromIndex);
}

Returns a cursor iterator that allows changes to the underlying list in parallel.

The cursor enables iteration and list changes to occur in any order without invalidating the iterator (from one thread). When elements are added to the list, an event is fired to all active cursors enabling them to adjust to the change in the list.

When the "current" (i.e., last returned by ListIterator#next or ListIterator#previous ) element of the list is removed, the cursor automatically adjusts to the change (invalidating the last returned value such that it cannot be removed).

 protected  void registerCursor(CursorableLinkedList.Cursor cursor) 
{
        // We take this opportunity to clean the cursors list
        // of WeakReference objects to garbage-collected cursors.
        for (Iterator it = cursors.iterator(); it.hasNext();) {
            WeakReference ref = (WeakReference) it.next();
            if (ref.get() == null) {
                it.remove();
            }
        }
        cursors.add(new WeakReference(cursor));
}

Registers a cursor to be notified of changes to this list.

 protected  void removeAllNodes() 
{
        if (size()  > 0) {
            // superclass implementation would break all the iterators
            Iterator it = iterator();
            while (it.hasNext()) {
                it.next();
                it.remove();
            }
        }
}

Removes all nodes by iteration.

 protected  void removeNode(Node node) 
{
        super.removeNode(node);
        broadcastNodeRemoved(node);
}

Removes the specified node from the list.

 protected  void unregisterCursor(CursorableLinkedList.Cursor cursor) 
{
        for (Iterator it = cursors.iterator(); it.hasNext();) {
            WeakReference ref = (WeakReference) it.next();
            Cursor cur = (Cursor) ref.get();
            if (cur == null) {
                // some other unrelated cursor object has been 
                // garbage-collected; let's take the opportunity to
                // clean up the cursors list anyway..
                it.remove();
            } else if (cur == cursor) {
                ref.clear();
                it.remove();
                break;
            }
        }
}

Deregisters a cursor from the list to be notified of changes.

 protected  void updateNode(Node node,
    Object value) 
{
        super.updateNode(node, value);
        broadcastNodeChanged(node);
}

Updates the node with a new value. This implementation sets the value on the node. Subclasses can override this to record the change.