| package net.sf.saxon.om; |
| |
| public final class Navigator { |
| |
| /** |
| * Determine if a string is all-whitespace |
| * |
| * @param content the string to be tested |
| * @return true if the supplied string contains no non-whitespace |
| * characters |
| */ |
| |
| public final static boolean isWhite(CharSequence content) { |
| for (int i=0; i<content.length();) { |
| // all valid XML whitespace characters, and only whitespace characters, are <= 0x20 |
| if (content.charAt(i++) > 32) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Get the string value of an attribute of a given element, given the URI and |
| * local part of the attribute name. |
| * @return the attribute value, or null if the attribute is not present |
| */ |
| |
| public static String getAttributeValue(NodeInfo element, String uri, String localName) { |
| int fingerprint = element.getNamePool().allocate("", uri, localName); |
| return element.getAttributeValue(fingerprint); |
| } |
| |
| /** |
| * Get an absolute XPath expression that identifies a given node within its document |
| * |
| * @param node the node whose path is required |
| * @return a path expression that can be used to retrieve the node |
| */ |
| |
| public static String getPath(NodeInfo node) { |
| String pre; |
| NodeInfo parent = node.getParent(); |
| // System.err.println("node = " + node + " parent = " + parent); |
| // Handle parentless nodes of any kind |
| if (parent==null) return "/"; |
| switch (node.getNodeKind()) { |
| case Type.DOCUMENT: |
| return "/"; |
| case Type.ELEMENT: |
| pre = getPath(parent); |
| return (pre.equals("/") ? "" : pre) + |
| "/" + node.getDisplayName() + "[" + getNumberSimple(node) + "]"; |
| case Type.ATTRIBUTE: |
| return getPath(parent) + "/@" + node.getDisplayName(); |
| case Type.TEXT: |
| pre = getPath(parent); |
| return (pre.equals("/") ? "" : pre) + |
| "/text()[" + getNumberSimple(node) + "]"; |
| case Type.COMMENT: |
| pre = getPath(parent); |
| return (pre.equals("/") ? "" : pre) + |
| "/comment()[" + getNumberSimple(node) + "]"; |
| case Type.PROCESSING_INSTRUCTION: |
| pre = getPath(parent); |
| return (pre.equals("/") ? "" : pre) + |
| "/processing-instruction()[" + getNumberSimple(node) + "]"; |
| default: |
| return ""; |
| } |
| } |
| |
| /** |
| * Get simple node number. This is defined as one plus the number of previous siblings of the |
| * same node type and name. It is not accessible directly in XSL. |
| * |
| * @param node The node whose number is required |
| * @param controller Used for remembering previous result, for |
| * performance |
| * @exception XPathException if any error occurs |
| * @return the node number, as defined above |
| */ |
| |
| public static int getNumberSimple(NodeInfo node, Controller controller) throws XPathException { |
| |
| //checkNumberable(node); |
| |
| int fingerprint = node.getFingerprint(); |
| NodeTest same; |
| |
| if (fingerprint==-1) { |
| same = NodeKindTest.makeNodeKindTest(node.getNodeKind()); |
| } else { |
| same = new NameTest(node); |
| } |
| |
| SequenceIterator preceding = node.iterateAxis(Axis.PRECEDING_SIBLING, same); |
| |
| int i=1; |
| while (true) { |
| NodeInfo prev = (NodeInfo)preceding.next(); |
| if (prev == null) { |
| break; |
| } |
| |
| int memo = controller.getRememberedNumber(prev); |
| if (memo>0) { |
| memo += i; |
| controller.setRememberedNumber(node, memo); |
| return memo; |
| } |
| |
| i++; |
| } |
| |
| controller.setRememberedNumber(node, i); |
| return i; |
| } |
| |
| /** |
| * Get simple node number. This is defined as one plus the number of previous siblings of the |
| * same node type and name. It is not accessible directly in XSL. This version doesn't require |
| * the controller, and therefore doesn't remember previous results. It is used only by getPath(). |
| * |
| * @param node the node whose number is required |
| * @return the node number, as defined above |
| */ |
| |
| private static int getNumberSimple(NodeInfo node) { |
| |
| int fingerprint = node.getFingerprint(); |
| NodeTest same; |
| |
| if (fingerprint==-1) { |
| same = NodeKindTest.makeNodeKindTest(node.getNodeKind()); |
| } else { |
| same = new NameTest(node); |
| } |
| |
| AxisIterator preceding = node.iterateAxis(Axis.PRECEDING_SIBLING, same); |
| |
| int i=1; |
| while (preceding.next() != null) { |
| i++; |
| } |
| |
| return i; |
| } |
| |
| /** |
| * Get node number (level="single"). If the current node matches the supplied pattern, the returned |
| * number is one plus the number of previous siblings that match the pattern. Otherwise, |
| * return the element number of the nearest ancestor that matches the supplied pattern. |
| * |
| * @param node the current node, the one whose node number is required |
| * @param count Pattern that identifies which nodes should be |
| * counted. Default (null) is the element name if the current node is |
| * an element, or "node()" otherwise. |
| * @param from Pattern that specifies where counting starts from. |
| * Default (null) is the root node. (This parameter does not seem |
| * useful but is included for the sake of XSLT conformance.) |
| * @param controller the controller of the transformation, used if |
| * the patterns reference context values (e.g. variables) |
| * @exception XPathException when any error occurs in processing |
| * @return the node number established as follows: go to the nearest |
| * ancestor-or-self that matches the 'count' pattern and that is a |
| * descendant of the nearest ancestor that matches the 'from' pattern. |
| * Return one plus the nunber of preceding siblings of that ancestor |
| * that match the 'count' pattern. If there is no such ancestor, |
| * return 0. |
| */ |
| |
| public static int getNumberSingle(NodeInfo node, Pattern count, |
| Pattern from, Controller controller) throws XPathException { |
| |
| // checkNumberable(node); |
| |
| if (count==null && from==null) { |
| return getNumberSimple(node, controller); |
| } |
| |
| boolean knownToMatch = false; |
| if (count==null) { |
| if (node.getFingerprint()==-1) { // unnamed node |
| count = NodeKindTest.makeNodeKindTest(node.getNodeKind()); |
| } else { |
| count = new NameTest(node); |
| } |
| knownToMatch = true; |
| } |
| |
| NodeInfo target = node; |
| while (!(knownToMatch || count.matches(target, controller))) { |
| target = target.getParent(); |
| if (target==null) { |
| return 0; |
| } |
| if (from!=null && from.matches(target, controller)) { |
| return 0; |
| } |
| } |
| |
| // we've found the ancestor to count from |
| |
| SequenceIterator preceding = |
| target.iterateAxis(Axis.PRECEDING_SIBLING, count.getNodeTest()); |
| // pass the filter condition down to the axis enumeration where possible |
| boolean alreadyChecked = (count instanceof NodeTest); |
| int i = 1; |
| while (true) { |
| NodeInfo p = (NodeInfo)preceding.next(); |
| if (p == null) { |
| return i; |
| } |
| if (alreadyChecked || count.matches(p, controller)) { |
| i++; |
| } |
| } |
| } |
| |
| /** |
| * Get node number (level="any"). |
| * Return one plus the number of previous nodes in the |
| * document that match the supplied pattern |
| * |
| * @exception XPathException |
| * @param inst Identifies the xsl:number instruction; this is relevant |
| * when the function is memoised to support repeated use of the same |
| * instruction to number modulple nodes |
| * @param node Identifies the xsl:number instruction; this is |
| * relevant when the function is memoised to support repeated use of |
| * the same instruction to number modulple nodes |
| * @param count Pattern that identifies which nodes should be |
| * counted. Default (null) is the element name if the current node is |
| * an element, or "node()" otherwise. |
| * @param from Pattern that specifies where counting starts from. |
| * Default (null) is the root node. Only nodes after the first (most |
| * recent) node that matches the 'from' pattern are counted. |
| * @param controller The controller |
| * @param hasVariablesInPatterns if the count or from patterns |
| * contain variables, then it's not safe to get the answer by adding |
| * one to the number of the most recent node that matches |
| * @return one plus the number of nodes that precede the current node, |
| * that match the count pattern, and that follow the first node that |
| * matches the from pattern if specified. |
| */ |
| |
| public static int getNumberAny(Instruction inst, NodeInfo node, Pattern count, |
| Pattern from, Controller controller, boolean hasVariablesInPatterns) throws XPathException { |
| |
| NodeInfo memoNode = null; |
| int memoNumber = 0; |
| boolean memoise = (!hasVariablesInPatterns && count!=null); |
| if (memoise) { |
| Object[] memo = (Object[])controller.getUserData(inst, "xsl:number"); |
| if (memo != null) { |
| memoNode = (NodeInfo)memo[0]; |
| memoNumber = ((Integer)memo[1]).intValue(); |
| } |
| } |
| |
| int num = 0; |
| if (count==null) { |
| if (node.getFingerprint()==-1) { // unnamed node |
| count = NodeKindTest.makeNodeKindTest(node.getNodeKind()); |
| } else { |
| count = new NameTest(node); |
| } |
| num = 1; |
| } else if (count.matches(node, controller)) { |
| num = 1; |
| } |
| |
| // We use a special axis invented for the purpose: the union of the preceding and |
| // ancestor axes, but in reverse document order |
| |
| // Pass part of the filtering down to the axis iterator if possible |
| NodeTest filter; |
| if (from==null) { |
| filter = count.getNodeTest(); |
| } else if (from.getNodeKind()==Type.ELEMENT && count.getNodeKind()==Type.ELEMENT) { |
| filter = NodeKindTest.ELEMENT; |
| } else { |
| filter = AnyNodeTest.getInstance(); |
| } |
| |
| SequenceIterator preceding = |
| node.iterateAxis(Axis.PRECEDING_OR_ANCESTOR, filter); |
| |
| while (true) { |
| NodeInfo prev = (NodeInfo)preceding.next(); |
| if (prev == null) { |
| break; |
| } |
| if (from!=null && from.matches(prev, controller)) { |
| return num; |
| } |
| if (count.matches(prev, controller)) { |
| if (num==1 && memoNode!=null && prev.isSameNode(memoNode)) { |
| num = memoNumber + 1; |
| break; |
| } |
| num++; |
| } |
| } |
| if (memoise) { |
| Object[] memo = new Object[2]; |
| memo[0] = node; |
| memo[1] = new Integer(num); |
| controller.setUserData(inst, "xsl:number", memo); |
| } |
| return num; |
| } |
| |
| /** |
| * Get node number (level="multiple"). |
| * Return a vector giving the hierarchic position of this node. See the XSLT spec for details. |
| * |
| * @exception XPathException |
| * @param node The node to be numbered |
| * @param count Pattern that identifies which nodes (ancestors and |
| * their previous siblings) should be counted. Default (null) is the |
| * element name if the current node is an element, or "node()" |
| * otherwise. |
| * @param from Pattern that specifies where counting starts from. |
| * Default (null) is the root node. Only nodes below the first (most |
| * recent) node that matches the 'from' pattern are counted. |
| * @param controller The controller for the transformation |
| * @return a vector containing for each ancestor-or-self that matches the |
| * count pattern and that is below the nearest node that matches the |
| * from pattern, an Integer which is one greater than the number of |
| * previous siblings that match the count pattern. |
| */ |
| |
| public static List getNumberMulti(NodeInfo node, Pattern count, |
| Pattern from, Controller controller) throws XPathException { |
| |
| //checkNumberable(node); |
| |
| ArrayList v = new ArrayList(); |
| |
| if (count==null) { |
| if (node.getFingerprint()==-1) { // unnamed node |
| count = NodeKindTest.makeNodeKindTest(node.getNodeKind()); |
| } else { |
| count = new NameTest(node); |
| } |
| } |
| |
| NodeInfo curr = node; |
| |
| while(true) { |
| if (count.matches(curr, controller)) { |
| int num = getNumberSingle(curr, count, null, controller); |
| v.add(0, new Long(num)); |
| } |
| curr = curr.getParent(); |
| if (curr==null) break; |
| if (from!=null && from.matches(curr, controller)) break; |
| } |
| |
| return v; |
| } |
| |
| /** |
| * Generic (model-independent) implementation of deep copy algorithm for nodes. |
| * This is available for use by any node implementations that choose to use it. |
| * @param node The node to be copied |
| * @param out The receiver to which events will be sent |
| * @param namePool Namepool holding the name codes (used only to resolve namespace |
| * codes) |
| * @param whichNamespaces Indicates which namespace nodes for an element should |
| * be copied |
| * @param copyAnnotations Indicates whether type annotations should be copied |
| * @throws TransformerException on any failure reported by the Receiver |
| */ |
| |
| public static void copy(NodeInfo node, |
| Receiver out, |
| NamePool namePool, |
| int whichNamespaces, |
| boolean copyAnnotations) throws TransformerException { |
| |
| switch (node.getNodeKind()) { |
| case Type.DOCUMENT: |
| AxisIterator children0 = node.iterateAxis(Axis.CHILD, new AnyNodeTest()); |
| while (true) { |
| NodeInfo child = (NodeInfo)children0.next(); |
| if (child == null) { |
| return; |
| } |
| child.copy(out, whichNamespaces, copyAnnotations); |
| } |
| |
| case Type.ELEMENT: |
| out.startElement(node.getNameCode(), 0, 0); |
| |
| // output the namespaces |
| |
| if (whichNamespaces != NodeInfo.NO_NAMESPACES) { |
| node.outputNamespaceNodes(out, true); |
| } |
| |
| // output the attributes |
| |
| AxisIterator attributes = node.iterateAxis(Axis.ATTRIBUTE, new AnyNodeTest()); |
| while (true) { |
| NodeInfo att = (NodeInfo)attributes.next(); |
| if (att == null) { |
| break; |
| } |
| att.copy(out, whichNamespaces, copyAnnotations); |
| } |
| |
| // output the children |
| |
| AxisIterator children = node.iterateAxis(Axis.CHILD, new AnyNodeTest()); |
| while (true) { |
| NodeInfo child = (NodeInfo)children.next(); |
| if (child == null) { |
| break; |
| } |
| child.copy(out, whichNamespaces, copyAnnotations); |
| } |
| |
| // finally the end tag |
| |
| out.endElement(); |
| return; |
| |
| case Type.ATTRIBUTE: |
| out.attribute(node.getNameCode(), 0, node.getStringValue(), 0); |
| return; |
| |
| case Type.TEXT: |
| out.characters(node.getStringValue(), 0); |
| return; |
| |
| case Type.COMMENT: |
| out.comment(node.getStringValue(), 0); |
| return; |
| |
| case Type.PROCESSING_INSTRUCTION: |
| out.processingInstruction(node.getLocalPart(), node.getStringValue(), 0); |
| return; |
| |
| case Type.NAMESPACE: |
| out.namespace(namePool.allocateNamespaceCode(node.getLocalPart(), node.getStringValue()),0); |
| return; |
| |
| default: |
| |
| } |
| } |
| |
| /** |
| * Generic (model-independent) method to determine the relative position of two |
| * node in document order. The nodes must be in the same tree. |
| * @param first The first node |
| * @param second The second node, whose position is to be compared with the first node |
| * @return -1 if this node precedes the other node, +1 if it follows the other |
| * node, or 0 if they are the same node. (In this case, isSameNode() will always |
| * return true, and the two nodes will produce the same result for generateId()) |
| */ |
| |
| public static int compareOrder(SiblingCountingNode first, SiblingCountingNode second) { |
| NodeInfo ow = second; |
| |
| // are they the same node? |
| if (first.isSameNode(second)) { |
| return 0; |
| } |
| // are they siblings (common case) |
| if (first.getParent().isSameNode(second.getParent())) { |
| return first.getSiblingPosition() - second.getSiblingPosition(); |
| } |
| // find the depths of both nodes in the tree |
| |
| int depth1 = 0; |
| int depth2 = 0; |
| NodeInfo p1 = first; |
| NodeInfo p2 = second; |
| while (p1 != null) { |
| depth1++; |
| p1 = p1.getParent(); |
| } |
| while (p2 != null) { |
| depth2++; |
| p2 = p2.getParent(); |
| } |
| // move up one branch of the tree so we have two nodes on the same level |
| |
| p1 = first; |
| while (depth1>depth2) { |
| p1 = p1.getParent(); |
| if (p1.isSameNode(second)) { |
| return +1; |
| } |
| depth1--; |
| } |
| |
| p2 = ow; |
| while (depth2>depth1) { |
| p2 = p2.getParent(); |
| if (p2.isSameNode(first)) { |
| return -1; |
| } |
| depth2--; |
| } |
| |
| // now move up both branches in sync until we find a common parent |
| while (true) { |
| NodeInfo par1 = p1.getParent(); |
| NodeInfo par2 = p2.getParent(); |
| if (par1==null || par2==null) { |
| throw new NullPointerException("DOM tree compare - internal error"); |
| } |
| if (par1.isSameNode(par2)) { |
| return ((SiblingCountingNode)p1).getSiblingPosition() - |
| ((SiblingCountingNode)p2).getSiblingPosition(); |
| } |
| p1 = par1; |
| p2 = par2; |
| } |
| } |
| |
| /** |
| * Get a character string that uniquely identifies this node and that collates nodes |
| * into document order |
| * @return a string. The string is always interned so keys can be compared using "==". |
| */ |
| |
| public static String getSequentialKey(SiblingCountingNode node) { |
| // TODO: this was designed so it could be used for sorting nodes into document |
| // order, but is not currently used that way. |
| StringBuffer key = new StringBuffer(); |
| while(!(node instanceof DocumentInfo)) { |
| key.insert(0, alphaKey(node.getSiblingPosition())); |
| node = (SiblingCountingNode)node.getParent(); |
| } |
| key.insert(0, "w" + node.getDocumentNumber()); |
| return key.toString().intern(); |
| } |
| |
| /** |
| * Construct an alphabetic key from an positive integer; the key collates in the same sequence |
| * as the integer |
| * @param value The positive integer key value (negative values are treated as zero). |
| */ |
| |
| public static String alphaKey(int value) { |
| if (value<1) return "a"; |
| if (value<10) return "b" + value; |
| if (value<100) return "c" + value; |
| if (value<1000) return "d" + value; |
| if (value<10000) return "e" + value; |
| if (value<100000) return "f" + value; |
| if (value<1000000) return "g" + value; |
| if (value<10000000) return "h" + value; |
| if (value<100000000) return "i" + value; |
| if (value<1000000000) return "j" + value; |
| return "k" + value; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Helper classes to support axis iteration |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * AxisFilter is an iterator that applies a NodeTest filter to |
| * the nodes returned by an underlying AxisIterator. |
| */ |
| |
| public static class AxisFilter extends AxisIteratorImpl { |
| private int last = -1; |
| |
| /** |
| * Construct a AxisFilter |
| * @param base the underlying iterator that returns all the nodes on |
| * a required axis. This must not be an atomizing iterator! |
| * @param test a NodeTest that is applied to each node returned by the |
| * underlying AxisIterator; only those nodes that pass the NodeTest are |
| * returned by the AxisFilter |
| */ |
| |
| public AxisFilter(AxisIterator base, NodeTest test) { |
| this.base = base; |
| this.nodeTest = test; |
| position = 0; |
| } |
| |
| public Item next() { |
| while (true) { |
| current = base.next(); |
| if (current == null) { |
| return null; |
| } |
| NodeInfo n = (NodeInfo)current; |
| if (nodeTest.matches(n.getNodeKind(), |
| n.getFingerprint(), |
| n.getTypeAnnotation())) { |
| position++; |
| return current; |
| } |
| } |
| } |
| |
| public int getLastPosition() { |
| |
| // To find out how many nodes there are in the axis, we |
| // make a copy of the original node enumeration, and run through |
| // the whole thing again, counting how many nodes match the filter. |
| |
| if (last>=0) { |
| return last; |
| } |
| last = 0; |
| AxisIterator b = (AxisIterator)base.getAnother(); |
| while (true) { |
| NodeInfo n = (NodeInfo)b.next(); |
| if (n == null) { |
| return last; |
| } |
| if (nodeTest.matches(n.getNodeKind(), |
| n.getFingerprint(), |
| n.getTypeAnnotation())) { |
| last++; |
| } |
| } |
| } |
| |
| public SequenceIterator getAnother() { |
| return new AxisFilter((AxisIterator)base.getAnother(), nodeTest); |
| } |
| } |
| } |
