Java example source code file (SAXImpl.java)
The SAXImpl.java Java example source code/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 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: SAXImpl.java,v 1.5 2005/09/28 13:48:37 pvedula Exp $
*/
package com.sun.org.apache.xalan.internal.xsltc.dom;
import java.net.URL;
import java.net.MalformedURLException;
import java.util.Enumeration;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.DOMEnhancedForDTM;
import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.BasisLibrary;
import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
import com.sun.org.apache.xml.internal.dtm.DTM;
import com.sun.org.apache.xml.internal.dtm.Axis;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.dtm.DTMManager;
import com.sun.org.apache.xml.internal.dtm.DTMWSFilter;
import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIterNodeList;
import com.sun.org.apache.xml.internal.dtm.ref.DTMDefaultBase;
import com.sun.org.apache.xml.internal.dtm.ref.EmptyIterator;
import com.sun.org.apache.xml.internal.dtm.ref.DTMNodeProxy;
import com.sun.org.apache.xml.internal.dtm.ref.sax2dtm.SAX2DTM2;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import com.sun.org.apache.xml.internal.serializer.ToXMLSAXHandler;
import com.sun.org.apache.xml.internal.utils.XMLStringFactory;
import com.sun.org.apache.xml.internal.utils.SystemIDResolver;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Entity;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
/**
* SAXImpl is the core model for SAX input source. SAXImpl objects are
* usually created from an XSLTCDTMManager.
*
* <p>DOMSource inputs are handled using DOM2SAX + SAXImpl. SAXImpl has a
* few specific fields (e.g. _node2Ids, _document) to keep DOM-related
* information. They are used when the processing behavior between DOM and
* SAX has to be different. Examples of these include id function and
* unparsed entity.
*
* <p>SAXImpl extends SAX2DTM2 instead of SAX2DTM for better performance.
* @author Jacek Ambroziak
* @author Santiago Pericas-Geertsen
* @author Morten Jorgensen
* @author Douglas Sellers <douglasjsellers@hotmail.com>
*/
public final class SAXImpl extends SAX2DTM2
implements DOMEnhancedForDTM, DOMBuilder
{
/* ------------------------------------------------------------------- */
/* DOMBuilder fields BEGIN */
/* ------------------------------------------------------------------- */
// Namespace prefix-to-uri mapping stuff
private int _uriCount = 0;
private int _prefixCount = 0;
// Stack used to keep track of what whitespace text nodes are protected
// by xml:space="preserve" attributes and which nodes that are not.
private int[] _xmlSpaceStack;
private int _idx = 1;
private boolean _preserve = false;
private static final String XML_STRING = "xml:";
private static final String XML_PREFIX = "xml";
private static final String XMLSPACE_STRING = "xml:space";
private static final String PRESERVE_STRING = "preserve";
private static final String XMLNS_PREFIX = "xmlns";
private static final String XML_URI = "http://www.w3.org/XML/1998/namespace";
private boolean _escaping = true;
private boolean _disableEscaping = false;
private int _textNodeToProcess = DTM.NULL;
/* ------------------------------------------------------------------- */
/* DOMBuilder fields END */
/* ------------------------------------------------------------------- */
// empty String for null attribute values
private final static String EMPTYSTRING = "";
// empty iterator to be returned when there are no children
private final static DTMAxisIterator EMPTYITERATOR = EmptyIterator.getInstance();
// The number of expanded names
private int _namesSize = -1;
// Namespace related stuff
private Hashtable _nsIndex = new Hashtable();
// The initial size of the text buffer
private int _size = 0;
// Tracks which textnodes are not escaped
private BitArray _dontEscape = null;
// The URI to this document
private String _documentURI = null;
static private int _documentURIIndex = 0;
// The owner Document when the input source is DOMSource.
private Document _document;
// The hashtable for org.w3c.dom.Node to node id mapping.
// This is only used when the input is a DOMSource and the
// buildIdIndex flag is true.
private Hashtable _node2Ids = null;
// True if the input source is a DOMSource.
private boolean _hasDOMSource = false;
// The DTMManager
private XSLTCDTMManager _dtmManager;
// Support for access/navigation through org.w3c.dom API
private Node[] _nodes;
private NodeList[] _nodeLists;
private final static String XML_LANG_ATTRIBUTE =
"http://www.w3.org/XML/1998/namespace:@lang";
/**
* Define the origin of the document from which the tree was built
*/
public void setDocumentURI(String uri) {
if (uri != null) {
setDocumentBaseURI(SystemIDResolver.getAbsoluteURI(uri));
}
}
/**
* Returns the origin of the document from which the tree was built
*/
public String getDocumentURI() {
String baseURI = getDocumentBaseURI();
return (baseURI != null) ? baseURI : "rtf" + _documentURIIndex++;
}
public String getDocumentURI(int node) {
return getDocumentURI();
}
public void setupMapping(String[] names, String[] urisArray,
int[] typesArray, String[] namespaces) {
// This method only has a function in DOM adapters
}
/**
* Lookup a namespace URI from a prefix starting at node. This method
* is used in the execution of xsl:element when the prefix is not known
* at compile time.
*/
public String lookupNamespace(int node, String prefix)
throws TransletException
{
int anode, nsnode;
final AncestorIterator ancestors = new AncestorIterator();
if (isElement(node)) {
ancestors.includeSelf();
}
ancestors.setStartNode(node);
while ((anode = ancestors.next()) != DTM.NULL) {
final NamespaceIterator namespaces = new NamespaceIterator();
namespaces.setStartNode(anode);
while ((nsnode = namespaces.next()) != DTM.NULL) {
if (getLocalName(nsnode).equals(prefix)) {
return getNodeValue(nsnode);
}
}
}
BasisLibrary.runTimeError(BasisLibrary.NAMESPACE_PREFIX_ERR, prefix);
return null;
}
/**
* Returns 'true' if a specific node is an element (of any type)
*/
public boolean isElement(final int node) {
return getNodeType(node) == DTM.ELEMENT_NODE;
}
/**
* Returns 'true' if a specific node is an attribute (of any type)
*/
public boolean isAttribute(final int node) {
return getNodeType(node) == DTM.ATTRIBUTE_NODE;
}
/**
* Returns the number of nodes in the tree (used for indexing)
*/
public int getSize() {
return getNumberOfNodes();
}
/**
* Part of the DOM interface - no function here.
*/
public void setFilter(StripFilter filter) {
}
/**
* Returns true if node1 comes before node2 in document order
*/
public boolean lessThan(int node1, int node2) {
if (node1 == DTM.NULL) {
return false;
}
if (node2 == DTM.NULL) {
return true;
}
return (node1 < node2);
}
/**
* Create an org.w3c.dom.Node from a node in the tree
*/
public Node makeNode(int index) {
if (_nodes == null) {
_nodes = new Node[_namesSize];
}
int nodeID = makeNodeIdentity(index);
if (nodeID < 0) {
return null;
}
else if (nodeID < _nodes.length) {
return (_nodes[nodeID] != null) ? _nodes[nodeID]
: (_nodes[nodeID] = new DTMNodeProxy((DTM)this, index));
}
else {
return new DTMNodeProxy((DTM)this, index);
}
}
/**
* Create an org.w3c.dom.Node from a node in an iterator
* The iterator most be started before this method is called
*/
public Node makeNode(DTMAxisIterator iter) {
return makeNode(iter.next());
}
/**
* Create an org.w3c.dom.NodeList from a node in the tree
*/
public NodeList makeNodeList(int index) {
if (_nodeLists == null) {
_nodeLists = new NodeList[_namesSize];
}
int nodeID = makeNodeIdentity(index);
if (nodeID < 0) {
return null;
}
else if (nodeID < _nodeLists.length) {
return (_nodeLists[nodeID] != null) ? _nodeLists[nodeID]
: (_nodeLists[nodeID] = new DTMAxisIterNodeList(this,
new SingletonIterator(index)));
}
else {
return new DTMAxisIterNodeList(this, new SingletonIterator(index));
}
}
/**
* Create an org.w3c.dom.NodeList from a node iterator
* The iterator most be started before this method is called
*/
public NodeList makeNodeList(DTMAxisIterator iter) {
return new DTMAxisIterNodeList(this, iter);
}
/**
* Iterator that returns the namespace nodes as defined by the XPath data
* model for a given node, filtered by extended type ID.
*/
public class TypedNamespaceIterator extends NamespaceIterator {
private String _nsPrefix;
/**
* Constructor TypedChildrenIterator
*
*
* @param nodeType The extended type ID being requested.
*/
public TypedNamespaceIterator(int nodeType) {
super();
if(m_expandedNameTable != null){
_nsPrefix = m_expandedNameTable.getLocalName(nodeType);
}
}
/**
* Get the next node in the iteration.
*
* @return The next node handle in the iteration, or END.
*/
public int next() {
if ((_nsPrefix == null) ||(_nsPrefix.length() == 0) ){
return (END);
}
int node = END;
for (node = super.next(); node != END; node = super.next()) {
if (_nsPrefix.compareTo(getLocalName(node))== 0) {
return returnNode(node);
}
}
return (END);
}
} // end of TypedNamespaceIterator
/**************************************************************
* This is a specialised iterator for predicates comparing node or
* attribute values to variable or parameter values.
*/
private final class NodeValueIterator extends InternalAxisIteratorBase
{
private DTMAxisIterator _source;
private String _value;
private boolean _op;
private final boolean _isReverse;
private int _returnType = RETURN_PARENT;
public NodeValueIterator(DTMAxisIterator source, int returnType,
String value, boolean op)
{
_source = source;
_returnType = returnType;
_value = value;
_op = op;
_isReverse = source.isReverse();
}
public boolean isReverse()
{
return _isReverse;
}
public DTMAxisIterator cloneIterator()
{
try {
NodeValueIterator clone = (NodeValueIterator)super.clone();
clone._isRestartable = false;
clone._source = _source.cloneIterator();
clone._value = _value;
clone._op = _op;
return clone.reset();
}
catch (CloneNotSupportedException e) {
BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR,
e.toString());
return null;
}
}
public void setRestartable(boolean isRestartable)
{
_isRestartable = isRestartable;
_source.setRestartable(isRestartable);
}
public DTMAxisIterator reset()
{
_source.reset();
return resetPosition();
}
public int next()
{
int node;
while ((node = _source.next()) != END) {
String val = getStringValueX(node);
if (_value.equals(val) == _op) {
if (_returnType == RETURN_CURRENT) {
return returnNode(node);
}
else {
return returnNode(getParent(node));
}
}
}
return END;
}
public DTMAxisIterator setStartNode(int node)
{
if (_isRestartable) {
_source.setStartNode(_startNode = node);
return resetPosition();
}
return this;
}
public void setMark()
{
_source.setMark();
}
public void gotoMark()
{
_source.gotoMark();
}
} // end NodeValueIterator
public DTMAxisIterator getNodeValueIterator(DTMAxisIterator iterator, int type,
String value, boolean op)
{
return(DTMAxisIterator)(new NodeValueIterator(iterator, type, value, op));
}
/**
* Encapsulates an iterator in an OrderedIterator to ensure node order
*/
public DTMAxisIterator orderNodes(DTMAxisIterator source, int node)
{
return new DupFilterIterator(source);
}
/**
* Returns singleton iterator containg the document root
* Works for them main document (mark == 0). It cannot be made
* to point to any other node through setStartNode().
*/
public DTMAxisIterator getIterator()
{
return new SingletonIterator(getDocument(), true);
}
/**
* Get mapping from DOM namespace types to external namespace types
*/
public int getNSType(int node)
{
String s = getNamespaceURI(node);
if (s == null) {
return 0;
}
int eType = getIdForNamespace(s);
return ((Integer)_nsIndex.get(new Integer(eType))).intValue();
}
/**
* Returns the namespace type of a specific node
*/
public int getNamespaceType(final int node)
{
return super.getNamespaceType(node);
}
/**
* Sets up a translet-to-dom type mapping table
*/
private int[] setupMapping(String[] names, String[] uris, int[] types, int nNames) {
// Padding with number of names, because they
// may need to be added, i.e for RTFs. See copy03
final int[] result = new int[m_expandedNameTable.getSize()];
for (int i = 0; i < nNames; i++) {
//int type = getGeneralizedType(namesArray[i]);
int type = m_expandedNameTable.getExpandedTypeID(uris[i], names[i], types[i], false);
result[type] = type;
}
return result;
}
/**
* Returns the internal type associated with an expanded QName
*/
public int getGeneralizedType(final String name) {
return getGeneralizedType(name, true);
}
/**
* Returns the internal type associated with an expanded QName
*/
public int getGeneralizedType(final String name, boolean searchOnly) {
String lName, ns = null;
int index = -1;
int code;
// Is there a prefix?
if ((index = name.lastIndexOf(":"))> -1) {
ns = name.substring(0, index);
}
// Local part of name is after colon. lastIndexOf returns -1 if
// there is no colon, so lNameStartIdx will be zero in that case.
int lNameStartIdx = index+1;
// Distinguish attribute and element names. Attribute has @ before
// local part of name.
if (name.charAt(lNameStartIdx) == '@') {
code = DTM.ATTRIBUTE_NODE;
lNameStartIdx++;
}
else {
code = DTM.ELEMENT_NODE;
}
// Extract local name
lName = (lNameStartIdx == 0) ? name : name.substring(lNameStartIdx);
return m_expandedNameTable.getExpandedTypeID(ns, lName, code, searchOnly);
}
/**
* Get mapping from DOM element/attribute types to external types
*/
public short[] getMapping(String[] names, String[] uris, int[] types)
{
// Delegate the work to getMapping2 if the document is not fully built.
// Some of the processing has to be different in this case.
if (_namesSize < 0) {
return getMapping2(names, uris, types);
}
int i;
final int namesLength = names.length;
final int exLength = m_expandedNameTable.getSize();
final short[] result = new short[exLength];
// primitive types map to themselves
for (i = 0; i < DTM.NTYPES; i++) {
result[i] = (short)i;
}
for (i = NTYPES; i < exLength; i++) {
result[i] = m_expandedNameTable.getType(i);
}
// actual mapping of caller requested names
for (i = 0; i < namesLength; i++) {
int genType = m_expandedNameTable.getExpandedTypeID(uris[i],
names[i],
types[i],
true);
if (genType >= 0 && genType < exLength) {
result[genType] = (short)(i + DTM.NTYPES);
}
}
return result;
}
/**
* Get mapping from external element/attribute types to DOM types
*/
public int[] getReverseMapping(String[] names, String[] uris, int[] types)
{
int i;
final int[] result = new int[names.length + DTM.NTYPES];
// primitive types map to themselves
for (i = 0; i < DTM.NTYPES; i++) {
result[i] = i;
}
// caller's types map into appropriate dom types
for (i = 0; i < names.length; i++) {
int type = m_expandedNameTable.getExpandedTypeID(uris[i], names[i], types[i], true);
result[i+DTM.NTYPES] = type;
}
return(result);
}
/**
* Get mapping from DOM element/attribute types to external types.
* This method is used when the document is not fully built.
*/
private short[] getMapping2(String[] names, String[] uris, int[] types)
{
int i;
final int namesLength = names.length;
final int exLength = m_expandedNameTable.getSize();
int[] generalizedTypes = null;
if (namesLength > 0) {
generalizedTypes = new int[namesLength];
}
int resultLength = exLength;
for (i = 0; i < namesLength; i++) {
// When the document is not fully built, the searchOnly
// flag should be set to false. That means we should add
// the type if it is not already in the expanded name table.
//generalizedTypes[i] = getGeneralizedType(names[i], false);
generalizedTypes[i] =
m_expandedNameTable.getExpandedTypeID(uris[i],
names[i],
types[i],
false);
if (_namesSize < 0 && generalizedTypes[i] >= resultLength) {
resultLength = generalizedTypes[i] + 1;
}
}
final short[] result = new short[resultLength];
// primitive types map to themselves
for (i = 0; i < DTM.NTYPES; i++) {
result[i] = (short)i;
}
for (i = NTYPES; i < exLength; i++) {
result[i] = m_expandedNameTable.getType(i);
}
// actual mapping of caller requested names
for (i = 0; i < namesLength; i++) {
int genType = generalizedTypes[i];
if (genType >= 0 && genType < resultLength) {
result[genType] = (short)(i + DTM.NTYPES);
}
}
return(result);
}
/**
* Get mapping from DOM namespace types to external namespace types
*/
public short[] getNamespaceMapping(String[] namespaces)
{
int i;
final int nsLength = namespaces.length;
final int mappingLength = _uriCount;
final short[] result = new short[mappingLength];
// Initialize all entries to -1
for (i=0; i<mappingLength; i++) {
result[i] = (short)(-1);
}
for (i=0; i<nsLength; i++) {
int eType = getIdForNamespace(namespaces[i]);
Integer type = (Integer)_nsIndex.get(new Integer(eType));
if (type != null) {
result[type.intValue()] = (short)i;
}
}
return(result);
}
/**
* Get mapping from external namespace types to DOM namespace types
*/
public short[] getReverseNamespaceMapping(String[] namespaces)
{
int i;
final int length = namespaces.length;
final short[] result = new short[length];
for (i = 0; i < length; i++) {
int eType = getIdForNamespace(namespaces[i]);
Integer type = (Integer)_nsIndex.get(new Integer(eType));
result[i] = (type == null) ? -1 : type.shortValue();
}
return result;
}
/**
* Construct a SAXImpl object using the default block size.
*/
public SAXImpl(XSLTCDTMManager mgr, Source source,
int dtmIdentity, DTMWSFilter whiteSpaceFilter,
XMLStringFactory xstringfactory,
boolean doIndexing, boolean buildIdIndex)
{
this(mgr, source, dtmIdentity, whiteSpaceFilter, xstringfactory,
doIndexing, DEFAULT_BLOCKSIZE, buildIdIndex, false);
}
/**
* Construct a SAXImpl object using the given block size.
*/
public SAXImpl(XSLTCDTMManager mgr, Source source,
int dtmIdentity, DTMWSFilter whiteSpaceFilter,
XMLStringFactory xstringfactory,
boolean doIndexing, int blocksize,
boolean buildIdIndex,
boolean newNameTable)
{
super(mgr, source, dtmIdentity, whiteSpaceFilter, xstringfactory,
doIndexing, blocksize, false, buildIdIndex, newNameTable);
_dtmManager = mgr;
_size = blocksize;
// Use a smaller size for the space stack if the blocksize is small
_xmlSpaceStack = new int[blocksize <= 64 ? 4 : 64];
/* From DOMBuilder */
_xmlSpaceStack[0] = DTMDefaultBase.ROOTNODE;
// If the input source is DOMSource, set the _document field and
// create the node2Ids table.
if (source instanceof DOMSource) {
_hasDOMSource = true;
DOMSource domsrc = (DOMSource)source;
Node node = domsrc.getNode();
if (node instanceof Document) {
_document = (Document)node;
}
else {
_document = node.getOwnerDocument();
}
_node2Ids = new Hashtable();
}
}
/**
* Migrate a DTM built with an old DTMManager to a new DTMManager.
* After the migration, the new DTMManager will treat the DTM as
* one that is built by itself.
* This is used to support DTM sharing between multiple transformations.
* @param manager the DTMManager
*/
public void migrateTo(DTMManager manager) {
super.migrateTo(manager);
if (manager instanceof XSLTCDTMManager) {
_dtmManager = (XSLTCDTMManager)manager;
}
}
/**
* Return the node identity for a given id String
*
* @param idString The id String
* @return The identity of the node whose id is the given String.
*/
public int getElementById(String idString)
{
Node node = _document.getElementById(idString);
if (node != null) {
Integer id = (Integer)_node2Ids.get(node);
return (id != null) ? id.intValue() : DTM.NULL;
}
else {
return DTM.NULL;
}
}
/**
* Return true if the input source is DOMSource.
*/
public boolean hasDOMSource()
{
return _hasDOMSource;
}
/*---------------------------------------------------------------------------*/
/* DOMBuilder methods begin */
/*---------------------------------------------------------------------------*/
/**
* Call this when an xml:space attribute is encountered to
* define the whitespace strip/preserve settings.
*/
private void xmlSpaceDefine(String val, final int node)
{
final boolean setting = val.equals(PRESERVE_STRING);
if (setting != _preserve) {
_xmlSpaceStack[_idx++] = node;
_preserve = setting;
}
}
/**
* Call this from endElement() to revert strip/preserve setting
* to whatever it was before the corresponding startElement().
*/
private void xmlSpaceRevert(final int node)
{
if (node == _xmlSpaceStack[_idx - 1]) {
_idx--;
_preserve = !_preserve;
}
}
/**
* Find out whether or not to strip whitespace nodes.
*
*
* @return whether or not to strip whitespace nodes.
*/
protected boolean getShouldStripWhitespace()
{
return _preserve ? false : super.getShouldStripWhitespace();
}
/**
* Creates a text-node and checks if it is a whitespace node.
*/
private void handleTextEscaping() {
if (_disableEscaping && _textNodeToProcess != DTM.NULL
&& _type(_textNodeToProcess) == DTM.TEXT_NODE) {
if (_dontEscape == null) {
_dontEscape = new BitArray(_size);
}
// Resize the _dontEscape BitArray if necessary.
if (_textNodeToProcess >= _dontEscape.size()) {
_dontEscape.resize(_dontEscape.size() * 2);
}
_dontEscape.setBit(_textNodeToProcess);
_disableEscaping = false;
}
_textNodeToProcess = DTM.NULL;
}
/****************************************************************/
/* SAX Interface Starts Here */
/****************************************************************/
/**
* SAX2: Receive notification of character data.
*/
public void characters(char[] ch, int start, int length) throws SAXException
{
super.characters(ch, start, length);
_disableEscaping = !_escaping;
_textNodeToProcess = getNumberOfNodes();
}
/**
* SAX2: Receive notification of the beginning of a document.
*/
public void startDocument() throws SAXException
{
super.startDocument();
_nsIndex.put(new Integer(0), new Integer(_uriCount++));
definePrefixAndUri(XML_PREFIX, XML_URI);
}
/**
* SAX2: Receive notification of the end of a document.
*/
public void endDocument() throws SAXException
{
super.endDocument();
handleTextEscaping();
_namesSize = m_expandedNameTable.getSize();
}
/**
* Specialized interface used by DOM2SAX. This one has an extra Node
* parameter to build the Node -> id map.
*/
public void startElement(String uri, String localName,
String qname, Attributes attributes,
Node node)
throws SAXException
{
this.startElement(uri, localName, qname, attributes);
if (m_buildIdIndex) {
_node2Ids.put(node, new Integer(m_parents.peek()));
}
}
/**
* SAX2: Receive notification of the beginning of an element.
*/
public void startElement(String uri, String localName,
String qname, Attributes attributes)
throws SAXException
{
super.startElement(uri, localName, qname, attributes);
handleTextEscaping();
if (m_wsfilter != null) {
// Look for any xml:space attributes
// Depending on the implementation of attributes, this
// might be faster than looping through all attributes. ILENE
final int index = attributes.getIndex(XMLSPACE_STRING);
if (index >= 0) {
xmlSpaceDefine(attributes.getValue(index), m_parents.peek());
}
}
}
/**
* SAX2: Receive notification of the end of an element.
*/
public void endElement(String namespaceURI, String localName, String qname)
throws SAXException
{
super.endElement(namespaceURI, localName, qname);
handleTextEscaping();
// Revert to strip/preserve-space setting from before this element
if (m_wsfilter != null) {
xmlSpaceRevert(m_previous);
}
}
/**
* SAX2: Receive notification of a processing instruction.
*/
public void processingInstruction(String target, String data)
throws SAXException
{
super.processingInstruction(target, data);
handleTextEscaping();
}
/**
* SAX2: Receive notification of ignorable whitespace in element
* content. Similar to characters(char[], int, int).
*/
public void ignorableWhitespace(char[] ch, int start, int length)
throws SAXException
{
super.ignorableWhitespace(ch, start, length);
_textNodeToProcess = getNumberOfNodes();
}
/**
* SAX2: Begin the scope of a prefix-URI Namespace mapping.
*/
public void startPrefixMapping(String prefix, String uri)
throws SAXException
{
super.startPrefixMapping(prefix, uri);
handleTextEscaping();
definePrefixAndUri(prefix, uri);
}
private void definePrefixAndUri(String prefix, String uri)
throws SAXException
{
// Check if the URI already exists before pushing on stack
Integer eType = new Integer(getIdForNamespace(uri));
if ((Integer)_nsIndex.get(eType) == null) {
_nsIndex.put(eType, new Integer(_uriCount++));
}
}
/**
* SAX2: Report an XML comment anywhere in the document.
*/
public void comment(char[] ch, int start, int length)
throws SAXException
{
super.comment(ch, start, length);
handleTextEscaping();
}
public boolean setEscaping(boolean value) {
final boolean temp = _escaping;
_escaping = value;
return temp;
}
/*---------------------------------------------------------------------------*/
/* DOMBuilder methods end */
/*---------------------------------------------------------------------------*/
/**
* Prints the whole tree to standard output
*/
public void print(int node, int level)
{
switch(getNodeType(node))
{
case DTM.ROOT_NODE:
case DTM.DOCUMENT_NODE:
print(getFirstChild(node), level);
break;
case DTM.TEXT_NODE:
case DTM.COMMENT_NODE:
case DTM.PROCESSING_INSTRUCTION_NODE:
System.out.print(getStringValueX(node));
break;
default:
final String name = getNodeName(node);
System.out.print("<" + name);
for (int a = getFirstAttribute(node); a != DTM.NULL; a = getNextAttribute(a))
{
System.out.print("\n" + getNodeName(a) + "=\"" + getStringValueX(a) + "\"");
}
System.out.print('>');
for (int child = getFirstChild(node); child != DTM.NULL;
child = getNextSibling(child)) {
print(child, level + 1);
}
System.out.println("</" + name + '>');
break;
}
}
/**
* Returns the name of a node (attribute or element).
*/
public String getNodeName(final int node)
{
// Get the node type and make sure that it is within limits
int nodeh = node;
final short type = getNodeType(nodeh);
switch(type)
{
case DTM.ROOT_NODE:
case DTM.DOCUMENT_NODE:
case DTM.TEXT_NODE:
case DTM.COMMENT_NODE:
return EMPTYSTRING;
case DTM.NAMESPACE_NODE:
return this.getLocalName(nodeh);
default:
return super.getNodeName(nodeh);
}
}
/**
* Returns the namespace URI to which a node belongs
*/
public String getNamespaceName(final int node)
{
if (node == DTM.NULL) {
return "";
}
String s;
return (s = getNamespaceURI(node)) == null ? EMPTYSTRING : s;
}
/**
* Returns the attribute node of a given type (if any) for an element
*/
public int getAttributeNode(final int type, final int element)
{
for (int attr = getFirstAttribute(element);
attr != DTM.NULL;
attr = getNextAttribute(attr))
{
if (getExpandedTypeID(attr) == type) return attr;
}
return DTM.NULL;
}
/**
* Returns the value of a given attribute type of a given element
*/
public String getAttributeValue(final int type, final int element)
{
final int attr = getAttributeNode(type, element);
return (attr != DTM.NULL) ? getStringValueX(attr) : EMPTYSTRING;
}
/**
* This method is for testing/debugging only
*/
public String getAttributeValue(final String name, final int element)
{
return getAttributeValue(getGeneralizedType(name), element);
}
/**
* Returns an iterator with all the children of a given node
*/
public DTMAxisIterator getChildren(final int node)
{
return (new ChildrenIterator()).setStartNode(node);
}
/**
* 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));
}
/**
* 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;
}
/**
* Similar to getAxisIterator, but this one returns an iterator
* containing nodes of a typed axis (ex.: child::foo)
*/
public DTMAxisIterator getTypedAxisIterator(int axis, int type)
{
// Most common case handled first
if (axis == Axis.CHILD) {
return new TypedChildrenIterator(type);
}
if (type == NO_TYPE) {
return(EMPTYITERATOR);
}
switch (axis)
{
case Axis.SELF:
return new TypedSingletonIterator(type);
case Axis.CHILD:
return new TypedChildrenIterator(type);
case Axis.PARENT:
return new ParentIterator().setNodeType(type);
case Axis.ANCESTOR:
return new TypedAncestorIterator(type);
case Axis.ANCESTORORSELF:
return (new TypedAncestorIterator(type)).includeSelf();
case Axis.ATTRIBUTE:
return new TypedAttributeIterator(type);
case Axis.DESCENDANT:
return new TypedDescendantIterator(type);
case Axis.DESCENDANTORSELF:
return (new TypedDescendantIterator(type)).includeSelf();
case Axis.FOLLOWING:
return new TypedFollowingIterator(type);
case Axis.PRECEDING:
return new TypedPrecedingIterator(type);
case Axis.FOLLOWINGSIBLING:
return new TypedFollowingSiblingIterator(type);
case Axis.PRECEDINGSIBLING:
return new TypedPrecedingSiblingIterator(type);
case Axis.NAMESPACE:
return new TypedNamespaceIterator(type);
case Axis.ROOT:
return new TypedRootIterator(type);
default:
BasisLibrary.runTimeError(BasisLibrary.TYPED_AXIS_SUPPORT_ERR,
Axis.getNames(axis));
}
return null;
}
/**
* Do not think that this returns an iterator for the namespace axis.
* It returns an iterator with nodes that belong in a certain namespace,
* such as with <xsl:apply-templates select="blob/foo:*"/>
* The 'axis' specifies the axis for the base iterator from which the
* nodes are taken, while 'ns' specifies the namespace URI type.
*/
public DTMAxisIterator getNamespaceAxisIterator(int axis, int ns)
{
DTMAxisIterator iterator = null;
if (ns == NO_TYPE) {
return EMPTYITERATOR;
}
else {
switch (axis) {
case Axis.CHILD:
return new NamespaceChildrenIterator(ns);
case Axis.ATTRIBUTE:
return new NamespaceAttributeIterator(ns);
default:
return new NamespaceWildcardIterator(axis, ns);
}
}
}
/**
* Iterator that handles node tests that test for a namespace, but have
* a wild card for the local name of the node, i.e., node tests of the
* form <axis>::
Other Java examples (source code examples)Here is a short list of links related to this Java SAXImpl.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
