import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
/**
 * Determines axis iteration algorithm. Throws {@code UnsupportedOperationException} in case,
 * when there is no axis iterator for given axisNumber.
 * @param axisNumber element from {@code AxisInfo}
 * @return {@code AxisIterator} object
 */
@Override
public AxisIterator iterateAxis(byte axisNumber) {
    final AxisIterator result;
    switch (axisNumber) {
        case AxisInfo.ANCESTOR:
        case AxisInfo.ATTRIBUTE:
        case AxisInfo.PARENT:
            result = EmptyIterator.OfNodes.THE_INSTANCE;
            break;
        case AxisInfo.ANCESTOR_OR_SELF:
        case AxisInfo.SELF:
            result = SingleNodeIterator.makeIterator(this);
            break;
        case AxisInfo.CHILD:
            if (hasChildNodes()) {
                result = new ArrayIterator.OfNodes(
                        getChildren().toArray(new AbstractNode[getChildren().size()]));
            }
            else {
                result = EmptyIterator.OfNodes.THE_INSTANCE;
            }
            break;
        case AxisInfo.DESCENDANT:
            if (hasChildNodes()) {
                result = new Navigator.DescendantEnumeration(this, false, true);
            }
            else {
                result = EmptyIterator.OfNodes.THE_INSTANCE;
            }
            break;
        case AxisInfo.DESCENDANT_OR_SELF:
            result = new Navigator.DescendantEnumeration(this, true, true);
            break;
        default:
            throw throwUnsupportedOperationException();
    }
    return result;
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
/**
 * Determines axis iteration algorithm.
 * @param axisNumber element from {@code AxisInfo}
 * @param nodeTest filter for iterator
 * @return {@code AxisIterator} object
 */
@Override
public AxisIterator iterateAxis(byte axisNumber, NodeTest nodeTest) {
    AxisIterator axisIterator = iterateAxis(axisNumber);
    if (nodeTest != null) {
        axisIterator = new Navigator.AxisFilter(axisIterator, nodeTest);
    }
    return axisIterator;
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
/**
 * Determines axis iteration algorithm. Throws {@code UnsupportedOperationException} in case,
 * when there is no axis iterator for given axisNumber.
 *
 * @param axisNumber element from {@code AxisInfo}
 * @return {@code AxisIterator} object
 */
@Override
public AxisIterator iterateAxis(byte axisNumber) {
    final AxisIterator result;
    switch (axisNumber) {
        case AxisInfo.ANCESTOR:
            result = new Navigator.AncestorEnumeration(this, false);
            break;
        case AxisInfo.ANCESTOR_OR_SELF:
            result = new Navigator.AncestorEnumeration(this, true);
            break;
        case AxisInfo.ATTRIBUTE:
            if (attributes == null) {
                result = EmptyIterator.OfNodes.THE_INSTANCE;
            }
            else {
                result = new ArrayIterator.OfNodes(attributes);
            }
            break;
        case AxisInfo.CHILD:
            if (hasChildNodes()) {
                result = new ArrayIterator.OfNodes(
                        getChildren().toArray(new AbstractNode[getChildren().size()]));
            }
            else {
                result = EmptyIterator.OfNodes.THE_INSTANCE;
            }
            break;
        case AxisInfo.DESCENDANT:
            if (hasChildNodes()) {
                result = new Navigator.DescendantEnumeration(this, false, true);
            }
            else {
                result = EmptyIterator.OfNodes.THE_INSTANCE;
            }
            break;
        case AxisInfo.DESCENDANT_OR_SELF:
            result = new Navigator.DescendantEnumeration(this, true, true);
            break;
        case AxisInfo.PARENT:
            result = SingleNodeIterator.makeIterator(parent);
            break;
        case AxisInfo.SELF:
            result = SingleNodeIterator.makeIterator(this);
            break;
        default:
            throw throwUnsupportedOperationException();
    }
    return result;
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
public String getXPath() {
  return Navigator.getPath(myElement);
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
public ElementImpl getDocumentElement() {
    return ((ElementImpl) Navigator.getOutermostElement(this.getUnderlyingNode()));
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
@Override
public int comparePosition(NodeInfo other) {
	return Navigator.comparePosition(this, other);
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
public static String getIndexedXPathExpression(NodeInfo nodeInfo) {
    return Navigator.getPath(nodeInfo);
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
@Override
public void copy(Receiver out, int copyOptions, int locationId) throws XPathException {
	Navigator.copy(this, out, copyOptions, locationId);
}
 

import net.sf.saxon.tree.util.Navigator; //导入依赖的package包/类
/**
 * Get a character string that uniquely identifies this node. Note:
 * a.isSameNode(b) if and only if generateId(a)==generateId(b)
 *
 * @param buffer a buffer to contain a string that uniquely identifies this node, across all documents
    */

public void generateId(FastStringBuffer buffer) {
       Navigator.appendSequentialKey(this, buffer, true);
	//buffer.append(Navigator.getSequentialKey(this));
}