@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)); } }
ObservableMutableDocument<? super E, E, ?> document = getDocument(); while (!obsoleteElements.isEmpty()) {
/** * Gets the value of an entry. * * @param element entry to evaluate * @return the value embedded in the element. */ private T valueOf(E element) { return serializer.fromString(getDocument().getAttribute(element, valueAttrName)); } }
/** * Handles an element being removed from the container. */ private void handleElementRemoved(E deletedElement) { // To start with though, we do a quick check to see if deletedElement has // the same tag name as value elements. if (!entryTagName.equals(getDocument().getTagName(deletedElement))) { // Exit, because deletedElement definitely isn't part of this container. return; } if (obsoleteElements.remove(deletedElement)) { // Element was obsolete, so ignore the removal event return; } T value = valueOf(deletedElement); E existingElement = valueElements.get(value); if (existingElement != deletedElement) { // deleted element was not part of the backing store for this map, so // ignore it } else { valueElements.remove(value); fireOnValueRemoved(value); } }
/** * Handles a new element being added to the container. If it represents a new * value, that value is recorded. If it represents a value already in this * container, either the old element or the new element is marked obsolete. * The element marked obsolete is the one that appears later in the document. */ private void handleElementAdded(E newElement) { ObservableMutableDocument<? super E, E, ?> document = getDocument(); assert container.equals(document.getParentElement(newElement)); if (!entryTagName.equals(document.getTagName(newElement))) { return; } T value = valueOf(newElement); E oldEntry = valueElements.get(value); if (oldEntry == null) { // Entry is for a new value - add it to the element map and fire an event // to collection listeners valueElements.put(value, newElement); fireOnValueAdded(value); } else if (document.getLocation(oldEntry) < document.getLocation(newElement)) { // newEntry is not needed, so mark it obsolete obsoleteElements.add(newElement); } else { // oldEntry is no needed, so mark it obsoleted and use the new one instead obsoleteElements.add(oldEntry); valueElements.put(value, newElement); } }
@Override public void add(T value) { Preconditions.checkNotNull(value, "value must not be null"); // Add an element to represent the value if (!valueElements.containsKey(value)) { Attributes attrs = new AttributesImpl(valueAttrName, serializer.toString(value)); getDocument().createChildElement(container, entryTagName, attrs); deleteObsoleteElements(); } }
/** * Initializes a new object. Call after construction is complete. */ private DocumentBasedBasicSet<E, T> init() { // Plumb events through router.addChildListener(container, new ElementListener<E>() { @Override public void onElementAdded(E element) { handleElementAdded(element); } @Override public void onElementRemoved(E element) { handleElementRemoved(element); } }); // Call handleElementAdded() to notify this class of existing data ObservableMutableDocument<? super E, E, ?> document = getDocument(); E curr = DocHelper.getFirstChildElement(document, container); E next; while (curr != null) { next = DocHelper.getNextSiblingElement(document, curr); handleElementAdded(curr); curr = next; } return this; }