diff options
Diffstat (limited to 'libjava/gnu/xml/dom/DomIterator.java')
| -rw-r--r-- | libjava/gnu/xml/dom/DomIterator.java | 373 |
1 files changed, 0 insertions, 373 deletions
diff --git a/libjava/gnu/xml/dom/DomIterator.java b/libjava/gnu/xml/dom/DomIterator.java deleted file mode 100644 index 472c6e80585..00000000000 --- a/libjava/gnu/xml/dom/DomIterator.java +++ /dev/null @@ -1,373 +0,0 @@ -/* DomIterator.java -- - Copyright (C) 1999,2000,2001 Free Software Foundation, Inc. - -This file is part of GNU Classpath. - -GNU Classpath is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU Classpath is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU Classpath; see the file COPYING. If not, write to the -Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301 USA. - -Linking this library statically or dynamically with other modules is -making a combined work based on this library. Thus, the terms and -conditions of the GNU General Public License cover the whole -combination. - -As a special exception, the copyright holders of this library give you -permission to link this library with independent modules to produce an -executable, regardless of the license terms of these independent -modules, and to copy and distribute the resulting executable under -terms of your choice, provided that you also meet, for each linked -independent module, the terms and conditions of the license of that -module. An independent module is a module which is not derived from -or based on this library. If you modify this library, you may extend -this exception to your version of the library, but you are not -obligated to do so. If you do not wish to do so, delete this -exception statement from your version. */ - -package gnu.xml.dom; - -import org.w3c.dom.DOMException; -import org.w3c.dom.Node; -import org.w3c.dom.events.Event; -import org.w3c.dom.events.EventListener; -import org.w3c.dom.events.EventTarget; -import org.w3c.dom.events.MutationEvent; -import org.w3c.dom.traversal.NodeFilter; -import org.w3c.dom.traversal.NodeIterator; - -/** - * <p> "NodeIterator" implementation, usable with any L2 DOM which - * supports MutationEvents. </p> - * - * @author David Brownell - */ -public final class DomIterator - implements NodeIterator, EventListener -{ - - private Node reference; - private boolean right; - private boolean done; - - private final Node root; - private final int whatToShow; - private final NodeFilter filter; - private final boolean expandEntityReferences; - - /** - * Constructs and initializes an iterator. - */ - protected DomIterator(Node root, - int whatToShow, - NodeFilter filter, - boolean entityReferenceExpansion) - { - if (!root.isSupported("MutationEvents", "2.0")) - { - throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR, - "Iterator needs mutation events", root, 0); - } - - this.root = root; - this.whatToShow = whatToShow; - this.filter = filter; - this.expandEntityReferences = entityReferenceExpansion; - - // start condition: going right, seen nothing yet. - reference = null; - right = true; - - EventTarget target = (EventTarget) root; - target.addEventListener("DOMNodeRemoved", this, false); - } - - /** - * <b>DOM L2</b> - * Flags the iterator as done, unregistering its event listener so - * that the iterator can be garbage collected without relying on weak - * references (a "Java 2" feature) in the event subsystem. - */ - public void detach() - { - EventTarget target = (EventTarget) root; - target.removeEventListener("DOMNodeRemoved", this, false); - done = true; - } - - /** - * <b>DOM L2</b> - * Returns the flag controlling whether iteration descends - * through entity references. - */ - public boolean getExpandEntityReferences() - { - return expandEntityReferences; - } - - /** - * <b>DOM L2</b> - * Returns the filter provided during construction. - */ - public NodeFilter getFilter() - { - return filter; - } - - /** - * <b>DOM L2</b> - * Returns the root of the tree this is iterating through. - */ - public Node getRoot() - { - return root; - } - - /** - * <b>DOM L2</b> - * Returns the mask of flags provided during construction. - */ - public int getWhatToShow() - { - return whatToShow; - } - - /** - * <b>DOM L2</b> - * Returns the next node in a forward iteration, masked and filtered. - * Note that the node may be read-only due to entity expansions. - * A null return indicates the iteration is complete, but may still - * be processed backwards. - */ - public Node nextNode() - { - if (done) - { - throw new DomDOMException(DOMException.INVALID_STATE_ERR); - } - right = true; - return walk(true); - } - - /** - * <b>DOM L2</b> - * Returns the next node in a backward iteration, masked and filtered. - * Note that the node may be read-only due to entity expansions. - * A null return indicates the iteration is complete, but may still - * be processed forwards. - */ - public Node previousNode() - { - if (done) - { - throw new DomDOMException(DOMException.INVALID_STATE_ERR); - } - Node previous = reference; - right = false; - walk(false); - return previous; - } - - private boolean shouldShow(Node node) - // raises Runtime exceptions indirectly, via acceptNode() - { - if ((whatToShow & (1 << (node.getNodeType() - 1))) == 0) - { - return false; - } - if (filter == null) - { - return true; - } - return filter.acceptNode(node) == NodeFilter.FILTER_ACCEPT; - } - - // - // scenario: root = 1, sequence = 1 2 ... 3 4 - // forward walk: 1 2 ... 3 4 null - // then backward: 4 3 ... 2 1 null - // - // At the leftmost end, "previous" == null - // At the rightmost end, "previous" == 4 - // - // The current draft spec really seem to make no sense re the - // role of the reference node, so what it says is ignored here. - // - private Node walk(boolean forward) - { - Node here = reference; - - while ((here = successor(here, forward)) != null - && !shouldShow(here)) - { - continue; - } - if (here != null || !forward) - { - reference = here; - } - return here; - } - - private boolean isLeaf(Node here) - { - boolean leaf = !here.hasChildNodes(); - if (!leaf && !expandEntityReferences) - { - leaf = (here.getNodeType() == Node.ENTITY_REFERENCE_NODE); - } - return leaf; - } - - // - // Returns the immediate successor in a forward (or backward) - // document order walk, sans filtering ... except that it knows - // how to stop, returning null when done. This is a depth first - // preorder traversal when run in the forward direction. - // - private Node successor(Node here, boolean forward) - { - Node next; - - // the "leftmost" end is funky - if (here == null) - { - return forward ? root : null; - } - - // - // Forward, this is preorder: children before siblings. - // Backward, it's postorder: we saw the children already. - // - if (forward && !isLeaf(here)) - { - return here.getFirstChild(); - } - - // - // Siblings ... if forward, we visit them, if backwards - // we visit their children first. - // - if (forward) - { - if ((next = here.getNextSibling()) != null) - { - return next; - } - } - else if ((next = here.getPreviousSibling()) != null) - { - if (isLeaf(next)) - { - return next; - } - next = next.getLastChild(); - while (!isLeaf(next)) - { - next = next.getLastChild(); - } - return next; - } - - // - // We can't go down or lateral -- it's up, then. The logic is - // the converse of what's above: backwards is easy (the parent - // is next), forwards isn't. - // - next = here.getParentNode(); - if (!forward) - { - return next; - } - - Node temp = null; - while (next != null - && next != root - && (temp = next.getNextSibling()) == null) - { - next = next.getParentNode(); - } - if (next == root) - { - return null; - } - return temp; - } - - /** - * Not for public use. This lets the iterator know when its - * reference node will be removed from the tree, so that a new - * one may be selected. - * - * <p> This version works by watching removal events as they - * bubble up. So, don't prevent them from bubbling. - */ - public void handleEvent(Event e) - { - MutationEvent event; - Node ancestor, removed; - - if (reference == null - || !"DOMNodeRemoved".equals(e.getType()) - || e.getEventPhase() != Event.BUBBLING_PHASE) - { - return; - } - - event = (MutationEvent) e; - removed = (Node) event.getTarget(); - - // See if the removal will cause trouble for this iterator - // by being the reference node or an ancestor of it. - for (ancestor = reference; - ancestor != null && ancestor != root; - ancestor = ancestor.getParentNode()) - { - if (ancestor == removed) - { - break; - } - } - if (ancestor != removed) - { - return; - } - - // OK, it'll cause trouble. We want to make the "next" - // node in our current traversal direction seem right. - // So we pick the nearest node that's not getting removed, - // but go in the _opposite_ direction from our current - // traversal ... so the "next" doesn't skip anything. - Node candidate; - -search: - while ((candidate = walk(!right)) != null) - { - for (ancestor = candidate; - ancestor != null && ancestor != root; - ancestor = ancestor.getParentNode()) - { - if (ancestor == removed) - { - continue search; - } - } - return; - } - - // The current DOM WD talks about a special case here; - // I've not yet seen it. - } - -} - |