/** * Deletes the container element. */ void delete() { doc.deleteNode(container); } }
private void cleanup() { if (!obsoleteEntries.isEmpty()) { ObservableMutableDocument<? super E, E, ?> document = getDocument(); Collection<E> toDelete = new ArrayList<E>(obsoleteEntries); for (E e : toDelete) { document.deleteNode(e); } // Deletion callbacks should cleanup obsoleteEntries collection one by one. assert obsoleteEntries.isEmpty(); } }
/** * Deletes the container element. */ void delete() { doc.deleteNode(container); } }
@Override public void remove() { router.getDocument().deleteNode(container); }
@Override public boolean remove(T child) { E element = valueToElement.remove(child); if (element == null) { return false; } getDocument().deleteNode(element); return true; }
@Override public void remove() { router.getDocument().deleteNode(container); }
@Override public void remove() { router.getDocument().deleteNode(container); }
private void cleanup() { if (!activeCleanUp) { assert obsoleteEntries.isEmpty(); return; } // Remove obsolete entries. // Copy obsoleteEntries by hand -- workaround for b/2087687. // Collection<E> toRemove = new ArrayList<E>(obsoleteEntries); Collection<E> toRemove = new ArrayList<E>(); for (E obsoleteEntry : obsoleteEntries) { toRemove.add(obsoleteEntry); } for (E e : toRemove) { getDocument().deleteNode(e); } // The callback firing should have emptied the obsoleteEntries collection. assert obsoleteEntries.isEmpty(); }
@Override public void clear() { if (!valueElements.isEmpty()) { deleteObsoleteElements(); // Remove every container element that corresponds to a value ObservableMutableDocument<? super E, E, ?> document = getDocument(); while (!valueElements.isEmpty()) { document.deleteNode(valueElements.values().iterator().next()); } } }
@Override public void remove(T value) { if (valueElements.containsKey(value)) { deleteObsoleteElements(); getDocument().deleteNode(valueElements.get(value)); } }
document.deleteNode(obsoleteElements.iterator().next());
/** * Deletes redundant elements. */ private void cleanup() { Boolean beforeValue = get(); // Delete all elements identified as redundant. We don't delete _every_ // element in the document in order that this type can be embedded // collaboratively in the same document as other types. Collection<E> toDelete = new ArrayList<E>(); toDelete.addAll(redundantElements); ObservableMutableDocument<? super E, E, ?> doc = getDocument(); for (E e : toDelete) { doc.deleteNode(e); } // Callbacks should have emptied the redundant collection. assert redundantElements.isEmpty(); // Check that cleanup did not change the interpretation. assert equals(beforeValue, get()); }
void removeEntries(K key) { N curChild = context.doc.getFirstChild(context.container); String keyString = keySerializer.toString(key); E e = DocHelper.getFirstChildElement(context.doc, context.container); while (e != null) { if (ENTRY_TAG.equals(context.doc.getTagName(e)) && keyString.equals(context.doc.getAttribute(e, KEY_ATTR))) { context.doc.deleteNode(e); } e = DocHelper.getNextSiblingElement(context.doc, e); } }
void removeEntries(K key) { N curChild = context.doc.getFirstChild(context.container); String keyString = keySerializer.toString(key); E e = DocHelper.getFirstChildElement(context.doc, context.container); while (e != null) { if (ENTRY_TAG.equals(context.doc.getTagName(e)) && keyString.equals(context.doc.getAttribute(e, KEY_ATTR))) { context.doc.deleteNode(e); } e = DocHelper.getNextSiblingElement(context.doc, e); } }
@Override public void set(Boolean newValue) { Boolean oldValue = get(); if (equals(oldValue, newValue)) { return; } if (newValue != null) { // Add an element to reflect new value. getDocument().createChildElement(container, tag, new AttributesImpl(valueAttr, Serializer.BOOLEAN.toString(newValue))); cleanup(); } else { // Erase all elements. Cleanup first, so that removal of real element // does not promote a redundant element temporarily. cleanup(); getDocument().deleteNode(valueElement); } assert equals(newValue, get()); }