/**
* Callers should not call next() after it returns END.
*
* <p><em>Use of an instance of this class as a {@link DTMAxisIterator} is <b>deprecated.</b></em>
*
* @deprecated
*/
public int next() {
if (_nodes == null) return DTMAxisIterator.END;
return (_position < _nodes.cardinality())
? _dom.getNodeHandle(_nodes.at(_position++))
: DTMAxisIterator.END;
}
/**
* Advance to the next node represented by this {@link HeapNode}
*
* @return the next DTM node.
*/
public int step() {
if (_position < _nodes.cardinality()) {
_node = _nodes.at(_position);
_position++;
} else {
_node = DTMAxisIterator.END;
}
return _node;
}
public int getNode(int index) {
if (index < _numCachedNodes) {
return _nodes.at(index);
} else if (!_isEnded) {
int node = _source.next();
if (node != END) {
_nodes.add(node);
_numCachedNodes++;
} else {
_isEnded = true;
}
return node;
} else return END;
}
private int computePositionOfLast() {
final int last = _nodes.cardinality();
final int currNode = _currentNode;
final AbstractTranslet translet = _translet;
int lastPosition = _position;
for (int index = _currentIndex; index < last; ) {
final int position = _docOrder ? index + 1 : last - index;
int nodeIndex = _nodes.at(index++); // note increment
if (_filter.test(nodeIndex, position, last, currNode, translet, this)) {
lastPosition++;
}
}
return lastPosition;
}
public int next() {
final int last = _nodes.cardinality();
final int currentNode = _currentNode;
final AbstractTranslet translet = _translet;
for (int index = _currentIndex; index < last; ) {
final int position = _docOrder ? index + 1 : last - index;
final int node = _nodes.at(index++); // note increment
if (_filter.test(node, position, last, currentNode, translet, this)) {
_currentIndex = index;
return returnNode(node);
}
}
return END;
}
/**
* Adds a node to the node list for a given value. Nodes will always be added in document order.
*/
public void add(Object value, int node, int rootNode) {
if (_currentDocumentNode != rootNode) {
_currentDocumentNode = rootNode;
_index = new Hashtable();
_rootToIndexMap.put(new Integer(rootNode), _index);
}
IntegerArray nodes = (IntegerArray) _index.get(value);
if (nodes == null) {
nodes = new IntegerArray();
_index.put(value, nodes);
nodes.add(node);
// Because nodes are added in document order,
// duplicates can be eliminated easily at this stage.
} else if (node != nodes.at(nodes.cardinality() - 1)) {
nodes.add(node);
}
}
/**
* Get the next node in the iteration.
*
* @return The next node handle in the iteration, or END.
*/
public int next() {
int nodeHandle;
// If at most one key value or at most one string argument to id
// resulted in nodes being returned, use the IntegerArray
// stored at _nodes directly. This relies on the fact that the
// IntegerArray never includes duplicate nodes and is always stored
// in document order.
if (_nodes != null) {
if (_position < _nodes.cardinality()) {
nodeHandle = returnNode(_nodes.at(_position));
} else {
nodeHandle = DTMAxisIterator.END;
}
} else {
nodeHandle = super.next();
}
return nodeHandle;
}
/**
* 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;
}
