|
Java example source code file (SAX2DTM2.java)
The SAX2DTM2.java Java example source code/* * reserved comment block * DO NOT REMOVE OR ALTER! */ /* * Copyright 1999-2005 The Apache Software Foundation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: SAX2DTM2.java,v 1.2.4.1 2005/09/15 08:15:12 suresh_emailid Exp $ */ package com.sun.org.apache.xml.internal.dtm.ref.sax2dtm; import com.sun.org.apache.xml.internal.dtm.*; import com.sun.org.apache.xml.internal.dtm.ref.*; import com.sun.org.apache.xml.internal.utils.FastStringBuffer; import com.sun.org.apache.xml.internal.utils.XMLString; import com.sun.org.apache.xml.internal.utils.XMLStringDefault; import com.sun.org.apache.xml.internal.utils.XMLStringFactory; import com.sun.org.apache.xml.internal.res.XMLMessages; import com.sun.org.apache.xml.internal.res.XMLErrorResources; import com.sun.org.apache.xml.internal.serializer.SerializationHandler; import javax.xml.transform.Source; import java.util.Vector; import com.sun.org.apache.xml.internal.utils.SuballocatedIntVector; import org.xml.sax.*; /** * SAX2DTM2 is an optimized version of SAX2DTM which is used in non-incremental situation. * It is used as the super class of the XSLTC SAXImpl. Many of the interfaces in SAX2DTM * and DTMDefaultBase are overridden in SAX2DTM2 in order to allow fast, efficient * access to the DTM model. Some nested iterators in DTMDefaultBaseIterators * are also overridden in SAX2DTM2 for performance reasons. * <p> * Performance is the biggest consideration in the design of SAX2DTM2. To make the code most * efficient, the incremental support is dropped in SAX2DTM2, which means that you should not * use it in incremental situation. To reduce the overhead of pulling data from the DTM model, * a few core interfaces in SAX2DTM2 have direct access to the internal arrays of the * SuballocatedIntVectors. * <p> * The design of SAX2DTM2 may limit its extensibilty. If you have a reason to extend the * SAX2DTM model, please extend from SAX2DTM instead of this class. * <p> * TODO: This class is currently only used by XSLTC. We need to investigate the possibility * of also using it in Xalan-J Interpretive. Xalan's performance is likely to get an instant * boost if we use SAX2DTM2 instead of SAX2DTM in non-incremental case. * <p> * %MK% The code in this class is critical to the XSLTC_DTM performance. Be very careful * when making changes here! */ public class SAX2DTM2 extends SAX2DTM { /**************************************************************** * Optimized version of the nested iterators ****************************************************************/ /** * Iterator that returns all immediate children of a given node */ public final class ChildrenIterator extends InternalAxisIteratorBase { /** * Setting start to END should 'close' the iterator, * i.e. subsequent call to next() should return END. * <p> * If the iterator is not restartable, this has no effect. * %REVIEW% Should it return/throw something in that case, * or set current node to END, to indicate request-not-honored? * * @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) { _startNode = node; _currentNode = (node == DTM.NULL) ? DTM.NULL : _firstch2(makeNodeIdentity(node)); return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END if no more * are available. */ public int next() { if (_currentNode != NULL) { int node = _currentNode; _currentNode = _nextsib2(node); return returnNode(makeNodeHandle(node)); } return END; } } // end of ChildrenIterator /** * Iterator that returns the parent of a given node. Note that * this delivers only a single node; if you want all the ancestors, * see AncestorIterator. */ public final class ParentIterator extends InternalAxisIteratorBase { /** The extended type ID that was requested. */ private int _nodeType = DTM.NULL; /** * 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) { _startNode = node; if (node != DTM.NULL) _currentNode = _parent2(makeNodeIdentity(node)); else _currentNode = DTM.NULL; return resetPosition(); } return this; } /** * Set the node type of the parent that we're looking for. * Note that this does _not_ mean "find the nearest ancestor of * this type", but "yield the parent if it is of this type". * * * @param type extended type ID. * * @return ParentIterator configured with the type filter set. */ public DTMAxisIterator setNodeType(final int type) { _nodeType = type; return this; } /** * Get the next node in the iteration. In this case, we return * only the immediate parent, _if_ it matches the requested nodeType. * * @return The next node handle in the iteration, or END. */ public int next() { int result = _currentNode; if (result == END) return DTM.NULL; // %OPT% The most common case is handled first. if (_nodeType == NULL) { _currentNode = END; return returnNode(makeNodeHandle(result)); } else if (_nodeType >= DTM.NTYPES) { if (_nodeType == _exptype2(result)) { _currentNode = END; return returnNode(makeNodeHandle(result)); } } else { if (_nodeType == _type2(result)) { _currentNode = END; return returnNode(makeNodeHandle(result)); } } return DTM.NULL; } } // end of ParentIterator /** * Iterator that returns children of a given type for a given node. * The functionality chould be achieved by putting a filter on top * of a basic child iterator, but a specialised iterator is used * for efficiency (both speed and size of translet). */ public final class TypedChildrenIterator extends InternalAxisIteratorBase { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedChildrenIterator * * * @param nodeType The extended type ID being requested. */ public TypedChildrenIterator(int nodeType) { _nodeType = nodeType; } /** * 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) { _startNode = node; _currentNode = (node == DTM.NULL) ? DTM.NULL : _firstch2(makeNodeIdentity(_startNode)); return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int node = _currentNode; if (node == DTM.NULL) return DTM.NULL; final int nodeType = _nodeType; if (nodeType != DTM.ELEMENT_NODE) { while (node != DTM.NULL && _exptype2(node) != nodeType) { node = _nextsib2(node); } } // %OPT% If the nodeType is element (matching child::*), we only // need to compare the expType with DTM.NTYPES. A child node of // an element can be either an element, text, comment or // processing instruction node. Only element node has an extended // type greater than or equal to DTM.NTYPES. else { int eType; while (node != DTM.NULL) { eType = _exptype2(node); if (eType >= DTM.NTYPES) break; else node = _nextsib2(node); } } if (node == DTM.NULL) { _currentNode = DTM.NULL; return DTM.NULL; } else { _currentNode = _nextsib2(node); return returnNode(makeNodeHandle(node)); } } /** * Return the node at the given position. */ public int getNodeByPosition(int position) { if (position <= 0) return DTM.NULL; int node = _currentNode; int pos = 0; final int nodeType = _nodeType; if (nodeType != DTM.ELEMENT_NODE) { while (node != DTM.NULL) { if (_exptype2(node) == nodeType) { pos++; if (pos == position) return makeNodeHandle(node); } node = _nextsib2(node); } return NULL; } else { while (node != DTM.NULL) { if (_exptype2(node) >= DTM.NTYPES) { pos++; if (pos == position) return makeNodeHandle(node); } node = _nextsib2(node); } return NULL; } } } // end of TypedChildrenIterator /** * Iterator that returns the namespace nodes as defined by the XPath data model * for a given node, filtered by extended type ID. */ public class TypedRootIterator extends RootIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedRootIterator * * @param nodeType The extended type ID being requested. */ public TypedRootIterator(int nodeType) { super(); _nodeType = nodeType; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { if(_startNode == _currentNode) return NULL; final int node = _startNode; int expType = _exptype2(makeNodeIdentity(node)); _currentNode = node; if (_nodeType >= DTM.NTYPES) { if (_nodeType == expType) { return returnNode(node); } } else { if (expType < DTM.NTYPES) { if (expType == _nodeType) { return returnNode(node); } } else { if (m_extendedTypes[expType].getNodeType() == _nodeType) { return returnNode(node); } } } return NULL; } } // end of TypedRootIterator /** * Iterator that returns all siblings of a given node. */ public class FollowingSiblingIterator extends InternalAxisIteratorBase { /** * 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) { _startNode = node; _currentNode = makeNodeIdentity(node); return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { _currentNode = (_currentNode == DTM.NULL) ? DTM.NULL : _nextsib2(_currentNode); return returnNode(makeNodeHandle(_currentNode)); } } // end of FollowingSiblingIterator /** * Iterator that returns all following siblings of a given node. */ public final class TypedFollowingSiblingIterator extends FollowingSiblingIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedFollowingSiblingIterator * * * @param type The extended type ID being requested. */ public TypedFollowingSiblingIterator(int type) { _nodeType = type; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { if (_currentNode == DTM.NULL) { return DTM.NULL; } int node = _currentNode; final int nodeType = _nodeType; if (nodeType != DTM.ELEMENT_NODE) { while ((node = _nextsib2(node)) != DTM.NULL && _exptype2(node) != nodeType) {} } else { while ((node = _nextsib2(node)) != DTM.NULL && _exptype2(node) < DTM.NTYPES) {} } _currentNode = node; return (node == DTM.NULL) ? DTM.NULL : returnNode(makeNodeHandle(node)); } } // end of TypedFollowingSiblingIterator /** * Iterator that returns attribute nodes (of what nodes?) */ public final class AttributeIterator extends InternalAxisIteratorBase { // assumes caller will pass element nodes /** * 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) { _startNode = node; _currentNode = getFirstAttributeIdentity(makeNodeIdentity(node)); return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { final int node = _currentNode; if (node != NULL) { _currentNode = getNextAttributeIdentity(node); return returnNode(makeNodeHandle(node)); } return NULL; } } // end of AttributeIterator /** * Iterator that returns attribute nodes of a given type */ public final class TypedAttributeIterator extends InternalAxisIteratorBase { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedAttributeIterator * * * @param nodeType The extended type ID that is requested. */ public TypedAttributeIterator(int nodeType) { _nodeType = nodeType; } // assumes caller will pass element nodes /** * 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; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { final int node = _currentNode; // singleton iterator, since there can only be one attribute of // a given type. _currentNode = NULL; return returnNode(node); } } // end of TypedAttributeIterator /** * Iterator that returns preceding siblings of a given node */ public class PrecedingSiblingIterator extends InternalAxisIteratorBase { /** * The node identity of _startNode for this iterator */ protected int _startNodeID; /** * True if this iterator has a reversed axis. * * @return true. */ public boolean isReverse() { return true; } /** * 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) { _startNode = node; node = _startNodeID = makeNodeIdentity(node); if(node == NULL) { _currentNode = node; return resetPosition(); } int type = _type2(node); if(ExpandedNameTable.ATTRIBUTE == type || ExpandedNameTable.NAMESPACE == type ) { _currentNode = node; } else { // Be careful to handle the Document node properly _currentNode = _parent2(node); if(NULL!=_currentNode) _currentNode = _firstch2(_currentNode); else _currentNode = node; } return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { if (_currentNode == _startNodeID || _currentNode == DTM.NULL) { return NULL; } else { final int node = _currentNode; _currentNode = _nextsib2(node); return returnNode(makeNodeHandle(node)); } } } // end of PrecedingSiblingIterator /** * Iterator that returns preceding siblings of a given type for * a given node */ public final class TypedPrecedingSiblingIterator extends PrecedingSiblingIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedPrecedingSiblingIterator * * * @param type The extended type ID being requested. */ public TypedPrecedingSiblingIterator(int type) { _nodeType = type; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int node = _currentNode; final int nodeType = _nodeType; final int startNodeID = _startNodeID; if (nodeType != DTM.ELEMENT_NODE) { while (node != NULL && node != startNodeID && _exptype2(node) != nodeType) { node = _nextsib2(node); } } else { while (node != NULL && node != startNodeID && _exptype2(node) < DTM.NTYPES) { node = _nextsib2(node); } } if (node == DTM.NULL || node == startNodeID) { _currentNode = NULL; return NULL; } else { _currentNode = _nextsib2(node); return returnNode(makeNodeHandle(node)); } } /** * Return the index of the last node in this iterator. */ public int getLast() { if (_last != -1) return _last; setMark(); int node = _currentNode; final int nodeType = _nodeType; final int startNodeID = _startNodeID; int last = 0; if (nodeType != DTM.ELEMENT_NODE) { while (node != NULL && node != startNodeID) { if (_exptype2(node) == nodeType) { last++; } node = _nextsib2(node); } } else { while (node != NULL && node != startNodeID) { if (_exptype2(node) >= DTM.NTYPES) { last++; } node = _nextsib2(node); } } gotoMark(); return (_last = last); } } // end of TypedPrecedingSiblingIterator /** * Iterator that returns preceding nodes of a given node. * This includes the node set {root+1, start-1}, but excludes * all ancestors, attributes, and namespace nodes. */ public class PrecedingIterator extends InternalAxisIteratorBase { /** The max ancestors, but it can grow... */ private final int _maxAncestors = 8; /** * The stack of start node + ancestors up to the root of the tree, * which we must avoid. */ protected int[] _stack = new int[_maxAncestors]; /** (not sure yet... -sb) */ protected int _sp, _oldsp; protected int _markedsp, _markedNode, _markedDescendant; /* _currentNode precedes candidates. This is the identity, not the handle! */ /** * True if this iterator has a reversed axis. * * @return true since this iterator is a reversed axis. */ public boolean isReverse() { return true; } /** * Returns a deep copy of this iterator. The cloned iterator is not reset. * * @return a deep copy of this iterator. */ public DTMAxisIterator cloneIterator() { _isRestartable = false; try { final PrecedingIterator clone = (PrecedingIterator) super.clone(); final int[] stackCopy = new int[_stack.length]; System.arraycopy(_stack, 0, stackCopy, 0, _stack.length); clone._stack = stackCopy; // return clone.reset(); return clone; } catch (CloneNotSupportedException e) { throw new DTMException(XMLMessages.createXMLMessage(XMLErrorResources.ER_ITERATOR_CLONE_NOT_SUPPORTED, null)); //"Iterator clone not supported."); } } /** * 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) { node = makeNodeIdentity(node); // iterator is not a clone int parent, index; if (_type2(node) == DTM.ATTRIBUTE_NODE) node = _parent2(node); _startNode = node; _stack[index = 0] = node; parent=node; while ((parent = _parent2(parent)) != NULL) { if (++index == _stack.length) { final int[] stack = new int[index*2]; System.arraycopy(_stack, 0, stack, 0, index); _stack = stack; } _stack[index] = parent; } if(index>0) --index; // Pop actual root node (if not start) back off the stack _currentNode=_stack[index]; // Last parent before root node _oldsp = _sp = index; return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { // Bugzilla 8324: We were forgetting to skip Attrs and NS nodes. // Also recoded the loop controls for clarity and to flatten out // the tail-recursion. for(++_currentNode; _sp>=0; ++_currentNode) { if(_currentNode < _stack[_sp]) { int type = _type2(_currentNode); if(type != ATTRIBUTE_NODE && type != NAMESPACE_NODE) return returnNode(makeNodeHandle(_currentNode)); } else --_sp; } return NULL; } // redefine DTMAxisIteratorBase's reset /** * Resets the iterator to the last start node. * * @return A DTMAxisIterator, which may or may not be the same as this * iterator. */ public DTMAxisIterator reset() { _sp = _oldsp; return resetPosition(); } public void setMark() { _markedsp = _sp; _markedNode = _currentNode; _markedDescendant = _stack[0]; } public void gotoMark() { _sp = _markedsp; _currentNode = _markedNode; } } // end of PrecedingIterator /** * Iterator that returns preceding nodes of agiven type for a * given node. This includes the node set {root+1, start-1}, but * excludes all ancestors. */ public final class TypedPrecedingIterator extends PrecedingIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedPrecedingIterator * * * @param type The extended type ID being requested. */ public TypedPrecedingIterator(int type) { _nodeType = type; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int node = _currentNode; final int nodeType = _nodeType; if (nodeType >= DTM.NTYPES) { while (true) { node++; if (_sp < 0) { node = NULL; break; } else if (node >= _stack[_sp]) { if (--_sp < 0) { node = NULL; break; } } else if (_exptype2(node) == nodeType) { break; } } } else { int expType; while (true) { node++; if (_sp < 0) { node = NULL; break; } else if (node >= _stack[_sp]) { if (--_sp < 0) { node = NULL; break; } } else { expType = _exptype2(node); if (expType < DTM.NTYPES) { if (expType == nodeType) { break; } } else { if (m_extendedTypes[expType].getNodeType() == nodeType) { break; } } } } } _currentNode = node; return (node == NULL) ? NULL : returnNode(makeNodeHandle(node)); } } // end of TypedPrecedingIterator /** * Iterator that returns following nodes of for a given node. */ public class FollowingIterator extends InternalAxisIteratorBase { //DTMAxisTraverser m_traverser; // easier for now public FollowingIterator() { //m_traverser = getAxisTraverser(Axis.FOLLOWING); } /** * 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) { _startNode = node; //_currentNode = m_traverser.first(node); node = makeNodeIdentity(node); int first; int type = _type2(node); if ((DTM.ATTRIBUTE_NODE == type) || (DTM.NAMESPACE_NODE == type)) { node = _parent2(node); first = _firstch2(node); if (NULL != first) { _currentNode = makeNodeHandle(first); return resetPosition(); } } do { first = _nextsib2(node); if (NULL == first) node = _parent2(node); } while (NULL == first && NULL != node); _currentNode = makeNodeHandle(first); // _currentNode precedes possible following(node) nodes return resetPosition(); } return this; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int node = _currentNode; //_currentNode = m_traverser.next(_startNode, _currentNode); int current = makeNodeIdentity(node); while (true) { current++; int type = _type2(current); if (NULL == type) { _currentNode = NULL; return returnNode(node); } if (ATTRIBUTE_NODE == type || NAMESPACE_NODE == type) continue; _currentNode = makeNodeHandle(current); return returnNode(node); } } } // end of FollowingIterator /** * Iterator that returns following nodes of a given type for a given node. */ public final class TypedFollowingIterator extends FollowingIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedFollowingIterator * * * @param type The extended type ID being requested. */ public TypedFollowingIterator(int type) { _nodeType = type; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int current; int node; int type; final int nodeType = _nodeType; int currentNodeID = makeNodeIdentity(_currentNode); if (nodeType >= DTM.NTYPES) { do { node = currentNodeID; current = node; do { current++; type = _type2(current); } while (type != NULL && (ATTRIBUTE_NODE == type || NAMESPACE_NODE == type)); currentNodeID = (type != NULL) ? current : NULL; } while (node != DTM.NULL && _exptype2(node) != nodeType); } else { do { node = currentNodeID; current = node; do { current++; type = _type2(current); } while (type != NULL && (ATTRIBUTE_NODE == type || NAMESPACE_NODE == type)); currentNodeID = (type != NULL) ? current : NULL; } while (node != DTM.NULL && (_exptype2(node) != nodeType && _type2(node) != nodeType)); } _currentNode = makeNodeHandle(currentNodeID); return (node == DTM.NULL ? DTM.NULL :returnNode(makeNodeHandle(node))); } } // end of TypedFollowingIterator /** * Iterator that returns the ancestors of a given node in document * order. (NOTE! This was changed from the XSLTC code!) */ public class AncestorIterator extends InternalAxisIteratorBase { // The initial size of the ancestor array private static final int m_blocksize = 32; // The array for ancestor nodes. This array will grow dynamically. int[] m_ancestors = new int[m_blocksize]; // Number of ancestor nodes in the array int m_size = 0; int m_ancestorsPos; int m_markedPos; /** The real start node for this axes, since _startNode will be adjusted. */ int m_realStartNode; /** * Get start to END should 'close' the iterator, * i.e. subsequent call to next() should return END. * * @return The root node of the iteration. */ public int getStartNode() { return m_realStartNode; } /** * True if this iterator has a reversed axis. * * @return true since this iterator is a reversed axis. */ public final boolean isReverse() { return true; } /** * Returns a deep copy of this iterator. The cloned iterator is not reset. * * @return a deep copy of this iterator. */ public DTMAxisIterator cloneIterator() { _isRestartable = false; // must set to false for any clone try { final AncestorIterator clone = (AncestorIterator) super.clone(); clone._startNode = _startNode; // return clone.reset(); return clone; } catch (CloneNotSupportedException e) { throw new DTMException(XMLMessages.createXMLMessage(XMLErrorResources.ER_ITERATOR_CLONE_NOT_SUPPORTED, null)); //"Iterator clone not supported."); } } /** * 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(); m_realStartNode = node; if (_isRestartable) { int nodeID = makeNodeIdentity(node); m_size = 0; if (nodeID == DTM.NULL) { _currentNode = DTM.NULL; m_ancestorsPos = 0; return this; } // Start from the current node's parent if // _includeSelf is false. if (!_includeSelf) { nodeID = _parent2(nodeID); node = makeNodeHandle(nodeID); } _startNode = node; while (nodeID != END) { //m_ancestors.addElement(node); if (m_size >= m_ancestors.length) { int[] newAncestors = new int[m_size * 2]; System.arraycopy(m_ancestors, 0, newAncestors, 0, m_ancestors.length); m_ancestors = newAncestors; } m_ancestors[m_size++] = node; nodeID = _parent2(nodeID); node = makeNodeHandle(nodeID); } m_ancestorsPos = m_size - 1; _currentNode = (m_ancestorsPos>=0) ? m_ancestors[m_ancestorsPos] : DTM.NULL; return resetPosition(); } return this; } /** * Resets the iterator to the last start node. * * @return A DTMAxisIterator, which may or may not be the same as this * iterator. */ public DTMAxisIterator reset() { m_ancestorsPos = m_size - 1; _currentNode = (m_ancestorsPos >= 0) ? m_ancestors[m_ancestorsPos] : DTM.NULL; return resetPosition(); } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { int next = _currentNode; int pos = --m_ancestorsPos; _currentNode = (pos >= 0) ? m_ancestors[m_ancestorsPos] : DTM.NULL; return returnNode(next); } public void setMark() { m_markedPos = m_ancestorsPos; } public void gotoMark() { m_ancestorsPos = m_markedPos; _currentNode = m_ancestorsPos>=0 ? m_ancestors[m_ancestorsPos] : DTM.NULL; } } // end of AncestorIterator /** * Typed iterator that returns the ancestors of a given node. */ public final class TypedAncestorIterator extends AncestorIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedAncestorIterator * * * @param type The extended type ID being requested. */ public TypedAncestorIterator(int type) { _nodeType = type; } /** * 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(); m_realStartNode = node; if (_isRestartable) { int nodeID = makeNodeIdentity(node); m_size = 0; if (nodeID == DTM.NULL) { _currentNode = DTM.NULL; m_ancestorsPos = 0; return this; } final int nodeType = _nodeType; if (!_includeSelf) { nodeID = _parent2(nodeID); node = makeNodeHandle(nodeID); } _startNode = node; if (nodeType >= DTM.NTYPES) { while (nodeID != END) { int eType = _exptype2(nodeID); if (eType == nodeType) { if (m_size >= m_ancestors.length) { int[] newAncestors = new int[m_size * 2]; System.arraycopy(m_ancestors, 0, newAncestors, 0, m_ancestors.length); m_ancestors = newAncestors; } m_ancestors[m_size++] = makeNodeHandle(nodeID); } nodeID = _parent2(nodeID); } } else { while (nodeID != END) { int eType = _exptype2(nodeID); if ((eType < DTM.NTYPES && eType == nodeType) || (eType >= DTM.NTYPES && m_extendedTypes[eType].getNodeType() == nodeType)) { if (m_size >= m_ancestors.length) { int[] newAncestors = new int[m_size * 2]; System.arraycopy(m_ancestors, 0, newAncestors, 0, m_ancestors.length); m_ancestors = newAncestors; } m_ancestors[m_size++] = makeNodeHandle(nodeID); } nodeID = _parent2(nodeID); } } m_ancestorsPos = m_size - 1; _currentNode = (m_ancestorsPos>=0) ? m_ancestors[m_ancestorsPos] : DTM.NULL; return resetPosition(); } return this; } /** * Return the node at the given position. */ public int getNodeByPosition(int position) { if (position > 0 && position <= m_size) { return m_ancestors[position-1]; } else return DTM.NULL; } /** * Returns the position of the last node within the iteration, as * defined by XPath. */ public int getLast() { return m_size; } } // end of TypedAncestorIterator /** * Iterator that returns the descendants of a given node. */ public class DescendantIterator extends InternalAxisIteratorBase { /** * 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) { node = makeNodeIdentity(node); _startNode = node; if (_includeSelf) node--; _currentNode = node; return resetPosition(); } return this; } /** * Tell if this node identity is a descendant. Assumes that * the node info for the element has already been obtained. * * This one-sided test works only if the parent has been * previously tested and is known to be a descendent. It fails if * the parent is the _startNode's next sibling, or indeed any node * that follows _startNode in document order. That may suffice * for this iterator, but it's not really an isDescendent() test. * %REVIEW% rename? * * @param identity The index number of the node in question. * @return true if the index is a descendant of _startNode. */ protected final boolean isDescendant(int identity) { return (_parent2(identity) >= _startNode) || (_startNode == identity); } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { final int startNode = _startNode; if (startNode == NULL) { return NULL; } if (_includeSelf && (_currentNode + 1) == startNode) return returnNode(makeNodeHandle(++_currentNode)); // | m_dtmIdent); int node = _currentNode; int type; // %OPT% If the startNode is the root node, do not need // to do the isDescendant() check. if (startNode == ROOTNODE) { int eType; do { node++; eType = _exptype2(node); if (NULL == eType) { _currentNode = NULL; return END; } } while (eType == TEXT_NODE || (type = m_extendedTypes[eType].getNodeType()) == ATTRIBUTE_NODE || type == NAMESPACE_NODE); } else { do { node++; type = _type2(node); if (NULL == type ||!isDescendant(node)) { _currentNode = NULL; return END; } } while(ATTRIBUTE_NODE == type || TEXT_NODE == type || NAMESPACE_NODE == type); } _currentNode = node; return returnNode(makeNodeHandle(node)); // make handle. } /** * Reset. * */ public DTMAxisIterator reset() { final boolean temp = _isRestartable; _isRestartable = true; setStartNode(makeNodeHandle(_startNode)); _isRestartable = temp; return this; } } // end of DescendantIterator /** * Typed iterator that returns the descendants of a given node. */ public final class TypedDescendantIterator extends DescendantIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedDescendantIterator * * * @param nodeType Extended type ID being requested. */ public TypedDescendantIterator(int nodeType) { _nodeType = nodeType; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { final int startNode = _startNode; if (_startNode == NULL) { return NULL; } int node = _currentNode; int expType; final int nodeType = _nodeType; if (nodeType != DTM.ELEMENT_NODE) { do { node++; expType = _exptype2(node); if (NULL == expType || _parent2(node) < startNode && startNode != node) { _currentNode = NULL; return END; } } while (expType != nodeType); } // %OPT% If the start node is root (e.g. in the case of //node), // we can save the isDescendant() check, because all nodes are // descendants of root. else if (startNode == DTMDefaultBase.ROOTNODE) { do { node++; expType = _exptype2(node); if (NULL == expType) { _currentNode = NULL; return END; } } while (expType < DTM.NTYPES || m_extendedTypes[expType].getNodeType() != DTM.ELEMENT_NODE); } else { do { node++; expType = _exptype2(node); if (NULL == expType || _parent2(node) < startNode && startNode != node) { _currentNode = NULL; return END; } } while (expType < DTM.NTYPES || m_extendedTypes[expType].getNodeType() != DTM.ELEMENT_NODE); } _currentNode = node; return returnNode(makeNodeHandle(node)); } } // end of TypedDescendantIterator /** * Iterator that returns a given node only if it is of a given type. */ public final class TypedSingletonIterator extends SingletonIterator { /** The extended type ID that was requested. */ private final int _nodeType; /** * Constructor TypedSingletonIterator * * * @param nodeType The extended type ID being requested. */ public TypedSingletonIterator(int nodeType) { _nodeType = nodeType; } /** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */ public int next() { final int result = _currentNode; if (result == END) return DTM.NULL; _currentNode = END; if (_nodeType >= DTM.NTYPES) { if (_exptype2(makeNodeIdentity(result)) == _nodeType) { return returnNode(result); } } else { if (_type2(makeNodeIdentity(result)) == _nodeType) { return returnNode(result); } } return NULL; } } // end of TypedSingletonIterator /******************************************************************* * End of nested iterators *******************************************************************/ // %OPT% Array references which are used to cache the map0 arrays in // SuballocatedIntVectors. Using the cached arrays reduces the level // of indirection and results in better performance than just calling // SuballocatedIntVector.elementAt(). private int[] m_exptype_map0; private int[] m_nextsib_map0; private int[] m_firstch_map0; private int[] m_parent_map0; // Double array references to the map arrays in SuballocatedIntVectors. private int[][] m_exptype_map; private int[][] m_nextsib_map; private int[][] m_firstch_map; private int[][] m_parent_map; // %OPT% Cache the array of extended types in this class protected ExtendedType[] m_extendedTypes; // A Vector which is used to store the values of attribute, namespace, // comment and PI nodes. // // %OPT% These values are unlikely to be equal. Storing // them in a plain Vector is more efficient than storing in the // DTMStringPool because we can save the cost for hash calculation. // // %REVISIT% Do we need a custom class (e.g. StringVector) here? protected Vector m_values; // The current index into the m_values Vector. private int m_valueIndex = 0; // The maximum value of the current node index. private int m_maxNodeIndex; // Cache the shift and mask values for the SuballocatedIntVectors. protected int m_SHIFT; protected int m_MASK; protected int m_blocksize; /** %OPT% If the offset and length of a Text node are within certain limits, * we store a bitwise encoded value into an int, using 10 bits (max. 1024) * for length and 21 bits for offset. We can save two SuballocatedIntVector * calls for each getStringValueX() and dispatchCharacterEvents() call by * doing this. */ // The number of bits for the length of a Text node. protected final static int TEXT_LENGTH_BITS = 10; // The number of bits for the offset of a Text node. protected final static int TEXT_OFFSET_BITS = 21; // The maximum length value protected final static int TEXT_LENGTH_MAX = (1< Other Java examples (source code examples)Here is a short list of links related to this Java SAX2DTM2.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.