com.sun.org.apache.xml.internal.dtm.DTMAxisIterator Java Examples

/**
 * Return the node at the given position.
 *
 * @param position The position
 * @return The node at the given position.
 */
public int getNodeByPosition(int position) {
    int node = DTMAxisIterator.END;

    // If nodes are stored in _nodes, take advantage of the fact that
    // there are no duplicates and they are stored in document order.
    // Otherwise, fall back to the base heap implementation to do a
    // good job with this.
    if (_nodes != null) {
        if (position > 0) {
            if (position <= _nodes.cardinality()) {
                _position = position;
                node = _nodes.at(position-1);
            } else {
                _position = _nodes.cardinality();
            }
        }
    } else {
        node = super.getNodeByPosition(position);
    }

    return node;
}
 

public DTMAxisIterator setStartNode(final int node) {
    if (node == DTM.NULL) {
        return this;
    }

    int dom = node >>> DTMManager.IDENT_DTM_NODE_BITS;

    // Get a new source first time and when mask changes
    if (_source == null || _dtmId != dom) {
        if (_type == NO_TYPE) {
            _source = _adapters[dom].getAxisIterator(_axis);
        } else if (_axis == Axis.CHILD) {
            _source = _adapters[dom].getTypedChildren(_type);
        } else {
            _source = _adapters[dom].getTypedAxisIterator(_axis, _type);
        }
    }

    _dtmId = dom;
    _source.setStartNode(node);
    return this;
}
 

/**
 * Set start to END should 'close' the iterator,
 * i.e. subsequent call to next() should return END.
 *
 * @param node Sets the root of the iteration.
 *
 * @return A DTMAxisIterator set to the start of the iteration.
 */
public DTMAxisIterator setStartNode(int node) {
    //%HZ%: Added reference to DTMDefaultBase.ROOTNODE back in, temporarily
    if (node == DTMDefaultBase.ROOTNODE) {
        node = getDocument();
    }

    if (_isRestartable) {
        int nsType = _nsType;

        _startNode = node;

        for (node = getFirstAttribute(node);
             node != END;
             node = getNextAttribute(node)) {
            if (getNSType(node) == nsType) {
                break;
            }
        }

        _currentNode = node;
        return resetPosition();
    }

    return this;
}
 

public DTMAxisIterator setStartNode(int nodeHandle)
{
    int nodeID = getNodeIdent(nodeHandle);
    _startNode = nodeID;

    // Increase the node ID by 1 if self is not included.
    if (!_includeSelf && nodeID != DTM.NULL) {
        if (_direction == DIRECTION_DOWN)
            nodeID++;
        else if (_direction == DIRECTION_UP)
            nodeID--;
    }

    _currentNode = nodeID;
    return this;
}
 

public NodeList makeNodeList(DTMAxisIterator iter) {
    int index = iter.next();
    if (index == DTM.NULL) {
        return new DTMAxisIterNodeList(null, null);
    }
    iter.reset();
    return _adapters[getDTMId(index)].makeNodeList(iter);
}
 

public static void copy(Object obj,
                        SerializationHandler handler,
                        int node,
                        DOM dom) {
    try {
        if (obj instanceof DTMAxisIterator)
  {
            DTMAxisIterator iter = (DTMAxisIterator) obj;
            dom.copy(iter.reset(), handler);
        }
        else if (obj instanceof Node) {
            dom.copy(((Node) obj).node, handler);
        }
        else if (obj instanceof DOM) {
            //((DOM)obj).copy(((com.sun.org.apache.xml.internal.dtm.ref.DTMDefaultBase)((DOMAdapter)obj).getDOMImpl()).getDocument(), handler);
            DOM newDom = (DOM)obj;
            newDom.copy(newDom.getDocument(), handler);
        }
        else {
            String string = obj.toString();         // or call stringF()
            final int length = string.length();
            if (length > _characterArray.length)
                _characterArray = new char[length];
            string.getChars(0, length, _characterArray, 0);
            handler.characters(_characterArray, 0, length);
        }
    }
    catch (SAXException e) {
        runTimeError(RUN_TIME_COPY_ERR);
    }
}
 

public DTMAxisIterator cloneIterator() {
    try {
        final AbsoluteIterator clone = (AbsoluteIterator) super.clone();
        clone._source = _source.cloneIterator();    // resets source
        clone.resetPosition();
        clone._isRestartable = false;
        return clone;
    }
    catch (CloneNotSupportedException e) {
        BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR,
                                  e.toString());
        return null;
    }
}
 

public void copy(DTMAxisIterator nodes, SerializationHandler handler)
    throws TransletException
{
    int node;
    while ((node = nodes.next()) != DTM.NULL)
    {
        copy(node, handler);
    }
}
 

public DTMAxisIterator reset() {
    for (int i = 0; i < _free; i++) {
        _heap[i].reset();
        _heap[i].step();
    }

    // build heap
    for (int i = (_heapSize = _free)/2; i >= 0; i--) {
        heapify(i);
    }

    _returnedLast = END;
    return resetPosition();
}
 

public DTMAxisIterator cloneIterator() {

        try {
            final MatchingIterator clone = (MatchingIterator) super.clone();
            clone._source = _source.cloneIterator();
            clone._isRestartable = false;
            return clone.reset();
        }
        catch (CloneNotSupportedException e) {
            BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR,
                                      e.toString());
            return null;
        }
    }
 

public CurrentNodeListIterator(DTMAxisIterator source, boolean docOrder,
                               CurrentNodeListFilter filter,
                               int currentNode,
                               AbstractTranslet translet)
{
    _source = source;
    _filter = filter;
    _translet = translet;
    _docOrder = docOrder;
    _currentNode = currentNode;
}
 

public DTMAxisIterator orderNodes(DTMAxisIterator source, int node)
{
    if (_dom != null) {
        return _dom.orderNodes(source, node);
    }
    else {
        return super.orderNodes(source, node);
    }
}
 

public DTMAxisIterator getAxisIterator(final int axis)
{
    if (_dom != null) {
        return _dom.getAxisIterator(axis);
    }
    else {
        return super.getAxisIterator(axis);
    }
}
 

/**
 * Copy a node-set to an output handler
 */
public void copy(DTMAxisIterator nodes, SerializationHandler handler)
    throws TransletException
{
    int node;
    while ((node = nodes.next()) != DTM.NULL) {
        copy(node, handler);
    }
}
 

public DTMAxisIterator getNthDescendant(int node, int n, boolean includeself)
{
    if (_dom != null) {
        return _dom.getNthDescendant(node, n, includeself);
    }
    else {
        return super.getNthDescendant(node, n, includeself);
    }
}
 

public DTMAxisIterator getChildren(final int node)
{
    if (_dom != null) {
        return _dom.getChildren(node);
    }
    else {
        return super.getChildren(node);
    }
}
 

public void copy(DTMAxisIterator nodes, SerializationHandler handler)
    throws TransletException
{
    if (_dom != null) {
        _dom.copy(nodes, handler);
    }
    else {
        super.copy(nodes, handler);
    }
}
 

public DTMAxisIterator setStartNode(int node) {
    if (_isRestartable) {
        _source.setStartNode(_startNode = node);
        return resetPosition();
    }
    return this;
}
 

/**
 * This is a shortcut to the iterators that implement the
 * supported XPath axes (only namespace::) is not supported.
 * Returns a bare-bones iterator that must be initialized
 * with a start node (using iterator.setStartNode()).
 */
public DTMAxisIterator getAxisIterator(final int axis)
{
    switch (axis)
    {
        case Axis.SELF:
            return new SingletonIterator();
        case Axis.CHILD:
            return new ChildrenIterator();
        case Axis.PARENT:
            return new ParentIterator();
        case Axis.ANCESTOR:
            return new AncestorIterator();
        case Axis.ANCESTORORSELF:
            return (new AncestorIterator()).includeSelf();
        case Axis.ATTRIBUTE:
            return new AttributeIterator();
        case Axis.DESCENDANT:
            return new DescendantIterator();
        case Axis.DESCENDANTORSELF:
            return (new DescendantIterator()).includeSelf();
        case Axis.FOLLOWING:
            return new FollowingIterator();
        case Axis.PRECEDING:
            return new PrecedingIterator();
        case Axis.FOLLOWINGSIBLING:
            return new FollowingSiblingIterator();
        case Axis.PRECEDINGSIBLING:
            return new PrecedingSiblingIterator();
        case Axis.NAMESPACE:
            return new NamespaceIterator();
        case Axis.ROOT:
            return new RootIterator();
        default:
            BasisLibrary.runTimeError(BasisLibrary.AXIS_SUPPORT_ERR,
                    Axis.getNames(axis));
    }
    return null;
}
 

public void copy(DTMAxisIterator nodes, SerializationHandler handler)
        throws TransletException
{
    int node;
    while ((node = nodes.next()) != DTM.NULL) {
        _adapters[node >>> DTMManager.IDENT_DTM_NODE_BITS].copy(node, handler);
    }
}
 

/**
 * Set start to END should 'close' the iterator,
 * i.e. subsequent call to next() should return END.
 *
 * @param node Sets the root of the iteration.
 *
 * @return A DTMAxisIterator set to the start of the iteration.
 */
public DTMAxisIterator setStartNode(int node) {
  if (_isRestartable) {
    _startNode = node;
    _currentNode = getTypedAttribute(node, _nodeType);
    return resetPosition();
  }

  return this;
}
 

public DTMAxisIterator getNthDescendant(int node, int n, boolean includeself)
{
    if (_dom != null) {
        return _dom.getNthDescendant(node, n, includeself);
    }
    else {
        return super.getNthDescendant(node, n, includeself);
    }
}
 

/**
 * XSLT Standard function string(value)
 */
public static String stringF(Object obj, DOM dom) {
    if (obj instanceof DTMAxisIterator) {
        return dom.getStringValueX(((DTMAxisIterator)obj).reset().next());
    }
    else if (obj instanceof Node) {
        return dom.getStringValueX(((Node)obj).node);
    }
    else if (obj instanceof DOM) {
        return ((DOM)obj).getStringValue();
    }
    else {
        return obj.toString();
    }
}
 

public DefaultMultipleNodeCounter(Translet translet,
                                  DOM document,
                                  DTMAxisIterator iterator) {
    super(translet, document, iterator);
}
 

public DTMAxisIterator reset() {
    _source.reset();
    return resetPosition();
}
 

public DTMAxisIterator reset() {
    _source.reset();
    return resetPosition();
}
 

public DTMAxisIterator setStartNode(int nodeHandle)
{
    _currentNode = _startNode = getNodeIdent(nodeHandle);
    return this;
}
 

public DTMAxisIterator forceNaturalOrder() {
    _docOrder = true;
    return this;
}
 

public MultipleNodeCounter(Translet translet,
                           DOM document, DTMAxisIterator iterator) {
    super(translet, document, iterator);
}
 

/**
 * Returns an iterator with all children of a specific type
 * for a given node (element)
 */
public DTMAxisIterator getTypedChildren(final int type)
{
    return(new TypedChildrenIterator(type));
}