/** * Returns a cursor iterator that allows changes to the underlying list in parallel. * <p> * 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. * <p> * When the "current" (i.e., last returned by {@link ListIterator#next} * or {@link 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). * * @return a new cursor iterator */ public ListIterator listIterator() { return cursor(0); }
/** * Updates the node with a new value. * This implementation sets the value on the node. * Subclasses can override this to record the change. * * @param node node to update * @param value new value of the node */ protected void updateNode(Node node, Object value) { super.updateNode(node, value); broadcastNodeChanged(node); }
public void testSerializationWithOpenCursor() throws Exception { list.add("A"); list.add("B"); list.add("C"); list.add("D"); list.add("E"); CursorableLinkedList.Cursor cursor = list.cursor(); java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream(); java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf); out.writeObject(list); out.flush(); out.close(); java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray()); java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin); Object list2 = in.readObject(); assertTrue(list != list2); assertTrue(list2.equals(list)); assertTrue(list.equals(list2)); }
public void testInternalState_CursorNextAddIndex1ByList() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); list.add(1, "Z"); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals("A", c1.current.value); assertEquals("Z", c1.next.value); assertEquals("[A, Z, B, C]", list.toString()); c1.remove(); // works ok assertEquals("[Z, B, C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }
public void testInternalState_CursorNextNextRemoveByListSetByIterator() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", c1.next()); list.remove(1); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(null, c1.current); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); try { c1.set("Z"); fail(); } catch (IllegalStateException ex) {} }
public void testCursorNextIndexMid() { list.add("1"); list.add("2"); list.add("3"); list.add("5"); CursorableLinkedList.Cursor c1 = list.cursor(); Iterator li = list.iterator(); // test cursors remain valid when list modified by std Iterator // test cursors skip elements removed via ListIterator assertEquals("1", li.next()); assertEquals("2", li.next()); li.remove(); assertEquals(0, c1.nextIndex()); assertEquals("1", c1.next()); assertEquals(1, c1.nextIndex()); assertEquals("3", c1.next()); }
/** * Creates a list iterator for the sublist. * * @param subList the sublist to get an iterator for * @param fromIndex the index to start from, relative to the sublist */ protected ListIterator createSubListListIterator(LinkedSubList subList, int fromIndex) { SubCursor cursor = new SubCursor(subList, fromIndex); registerCursor(cursor); return cursor; }
/** * Deserializes the data held in this object to the stream specified. */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); doReadObject(in); }
/** * Serializes the data held in this object to the stream specified. */ private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); doWriteObject(out); }
/** * Removes the specified node from the list. * * @param node the node to remove * @throws NullPointerException if <code>node</code> is null */ protected void removeNode(Node node) { super.removeNode(node); broadcastNodeRemoved(node); }
/** * Inserts a new node into the list. * * @param nodeToInsert new node to insert * @param insertBeforeNode node to insert before * @throws NullPointerException if either node is null */ protected void addNode(Node nodeToInsert, Node insertBeforeNode) { super.addNode(nodeToInsert, insertBeforeNode); broadcastNodeInserted(nodeToInsert); }
/** * Constructor that creates. */ public CursorableLinkedList() { super(); init(); // must call init() as use super(); }
public void testClear() { assertEquals(0,list.size()); assertTrue(list.isEmpty()); list.clear(); assertEquals(0,list.size()); assertTrue(list.isEmpty()); list.add("element"); assertEquals(1,list.size()); assertTrue(!list.isEmpty()); list.clear(); assertEquals(0,list.size()); assertTrue(list.isEmpty()); list.add("element1"); list.add("element2"); assertEquals(2,list.size()); assertTrue(!list.isEmpty()); list.clear(); assertEquals(0,list.size()); assertTrue(list.isEmpty()); for(int i=0;i<1000;i++) { list.add(new Integer(i)); } assertEquals(1000,list.size()); assertTrue(!list.isEmpty()); list.clear(); assertEquals(0,list.size()); assertTrue(list.isEmpty()); }
public void testCursorNextIndexFirst() { list.add("1"); list.add("2"); list.add("3"); list.add("5"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals(0, c1.nextIndex()); list.remove(0); assertEquals(0, c1.nextIndex()); assertEquals("2", c1.next()); assertEquals(1, c1.nextIndex()); assertEquals("3", c1.next()); }
public void testIterator() { list.add("1"); list.add("2"); list.add("3"); list.add("4"); list.add("5"); Iterator it = list.iterator(); assertTrue(it.hasNext()); assertEquals("1",it.next()); it = list.iterator(); assertTrue(it.hasNext()); assertEquals("1",it.next()); it.remove(); assertEquals("[2, 3, 4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("2",it.next()); it.remove(); assertEquals("[3, 4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("3",it.next()); it.remove(); assertEquals("[4, 5]",list.toString()); assertTrue(it.hasNext()); assertEquals("4",it.next()); it.remove(); assertEquals("[5]",list.toString()); assertTrue(it.hasNext()); assertEquals("5",it.next()); it.remove();
public void testCursorAdd() { CursorableLinkedList.Cursor it = list.cursor(); it.add("1"); assertEquals("[1]",list.toString()); it.add("3"); assertEquals("[1, 3]",list.toString()); it.add("5"); assertEquals("[1, 3, 5]",list.toString()); assertEquals("5",it.previous()); it.add("4"); assertEquals("[1, 3, 4, 5]",list.toString()); assertEquals("4",it.previous()); assertEquals("3",it.previous()); it.add("2"); assertEquals("[1, 2, 3, 4, 5]",list.toString()); it.close(); }
public void testInternalState_CursorNextNextAddIndex1ByList() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", c1.next()); list.add(1, "Z"); assertEquals(false, c1.nextIndexValid); assertEquals("B", c1.current.value); assertEquals("C", c1.next.value); assertEquals("[A, Z, B, C]", list.toString()); c1.remove(); // works ok assertEquals("[A, Z, C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }
public void testInternalState_CursorNextRemoveIndex1ByList() { list.add("A"); list.add("B"); list.add("C"); CursorableLinkedList.Cursor c1 = list.cursor(); assertEquals("A", c1.next()); assertEquals("B", list.remove(1)); assertEquals(true, c1.nextIndexValid); assertEquals(1, c1.nextIndex); assertEquals(false, c1.currentRemovedByAnother); assertEquals("A", c1.current.value); assertEquals("C", c1.next.value); assertEquals("[A, C]", list.toString()); c1.remove(); // works ok assertEquals("[C]", list.toString()); try { c1.remove(); fail(); } catch (IllegalStateException ex) {} }