/*
 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

package com.sun.org.apache.xalan.internal.xsltc.dom;

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.xml.internal.dtm.Axis;
import com.sun.org.apache.xml.internal.dtm.DTM;
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.DTMNodeProxy;
import com.sun.org.apache.xml.internal.dtm.ref.EmptyIterator;
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.SystemIDResolver;
import com.sun.org.apache.xml.internal.utils.XMLStringFactory;
import java.util.HashMap;
import java.util.Map;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Entity;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
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.

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.

SAXImpl extends SAX2DTM2 instead of SAX2DTM for better performance.

Author:Jacek Ambroziak, Santiago Pericas-Geertsen, Morten Jorgensen, Douglas Sellers
@LastModified: Oct 2017
/** * 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> * @LastModified: Oct 2017 */
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 Map<Integer, Integer> _nsIndex = new HashMap<>(); // 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 Map 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 Map<Node, Integer> _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
/** * 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
/** * 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.
/** * 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)
/** * 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)
/** * 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)
/** * Returns the number of nodes in the tree (used for indexing) */
public int getSize() { return getNumberOfNodes(); }
Part of the DOM interface - no function here.
/** * Part of the DOM interface - no function here. */
public void setFilter(StripFilter filter) { }
Returns true if node1 comes before node2 in document order
/** * 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
/** * 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
/** * 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
/** * 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
/** * 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.
/** * 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
Params:
  • nodeType – The extended type ID being requested.
/** * 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.
Returns:The next node handle in the iteration, or END.
/** * 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.
/************************************************************** * 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
/** * 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().
/** * 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
/** * 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 _nsIndex.get(eType); }
Returns the namespace type of a specific node
/** * 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
/** * 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
/** * 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
/** * 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
/** * 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.
/** * 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
/** * 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 = _nsIndex.get(eType); if (type != null) { result[type] = (short)i; } } return(result); }
Get mapping from external namespace types to DOM namespace types
/** * 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 = _nsIndex.get(eType); result[i] = (type == null) ? -1 : type.shortValue(); } return result; }
Construct a SAXImpl object using the default block size.
/** * 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.
/** * 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 HashMap<>(); } }
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.
Params:
  • manager – the DTMManager
/** * 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
Params:
  • idString – The id String
Returns:The identity of the node whose id is the given String.
/** * 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 = _node2Ids.get(node); return (id != null) ? id : DTM.NULL; } else { return DTM.NULL; } }
Return true if the input source is DOMSource.
/** * 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.
/** * 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().
/** * 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.
Returns:whether or not to strip whitespace nodes.
/** * 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.
/** * 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.
/** * 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.
/** * SAX2: Receive notification of the beginning of a document. */
public void startDocument() throws SAXException { super.startDocument(); _nsIndex.put(0, _uriCount++); definePrefixAndUri(XML_PREFIX, XML_URI); }
SAX2: Receive notification of the end of a document.
/** * 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.
/** * 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, m_parents.peek()); } }
SAX2: Receive notification of the beginning of an element.
/** * 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.
/** * 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.
/** * 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).
/** * 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.
/** * 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 = getIdForNamespace(uri); if (_nsIndex.get(eType) == null) { _nsIndex.put(eType, _uriCount++); } }
SAX2: Report an XML comment anywhere in the document.
/** * 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
/** * 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).
/** * 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
/** * 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
/** * 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
/** * 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
/** * 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
/** * 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)
/** * 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()).
/** * 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)
/** * 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 The 'axis' specifies the axis for the base iterator from which the nodes are taken, while 'ns' specifies the namespace URI type.
/** * 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) { 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 :::*
/** * 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>::<prefix>:* */
public final class NamespaceWildcardIterator extends InternalAxisIteratorBase {
The namespace type index.
/** * The namespace type index. */
protected int m_nsType;
A nested typed axis iterator that retrieves nodes of the principal node kind for that axis.
/** * A nested typed axis iterator that retrieves nodes of the principal * node kind for that axis. */
protected DTMAxisIterator m_baseIterator;
Constructor NamespaceWildcard
Params:
  • axis – The axis that this iterator will traverse
  • nsType – The namespace type index
/** * Constructor NamespaceWildcard * * @param axis The axis that this iterator will traverse * @param nsType The namespace type index */
public NamespaceWildcardIterator(int axis, int nsType) { m_nsType = nsType; // Create a nested iterator that will select nodes of // the principal node kind for the selected axis. switch (axis) { case Axis.ATTRIBUTE: { // For "attribute::p:*", the principal node kind is // attribute m_baseIterator = getAxisIterator(axis); break; } case Axis.NAMESPACE: { // This covers "namespace::p:*". It is syntactically // correct, though it doesn't make much sense. m_baseIterator = getAxisIterator(axis); break; } default: { // In all other cases, the principal node kind is // element m_baseIterator = getTypedAxisIterator(axis, DTM.ELEMENT_NODE); } } }
Set start to END should 'close' the iterator, i.e. subsequent call to next() should return END.
Params:
  • node – Sets the root of the iteration.
Returns:A DTMAxisIterator set to the start of the iteration.
/** * 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; m_baseIterator.setStartNode(node); resetPosition(); } return this; }
Get the next node in the iteration.
Returns:The next node handle in the iteration, or END.
/** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */
public int next() { int node; while ((node = m_baseIterator.next()) != END) { // Return only nodes that are in the selected namespace if (getNSType(node) == m_nsType) { return returnNode(node); } } return END; }
Returns a deep copy of this iterator. The cloned iterator is not reset.
Returns:a deep copy of this iterator.
/** * Returns a deep copy of this iterator. The cloned iterator is not * reset. * * @return a deep copy of this iterator. */
public DTMAxisIterator cloneIterator() { try { DTMAxisIterator nestedClone = m_baseIterator.cloneIterator(); NamespaceWildcardIterator clone = (NamespaceWildcardIterator) super.clone(); clone.m_baseIterator = nestedClone; clone.m_nsType = m_nsType; clone._isRestartable = false; return clone; } catch (CloneNotSupportedException e) { BasisLibrary.runTimeError(BasisLibrary.ITERATOR_CLONE_ERR, e.toString()); return null; } }
True if this iterator has a reversed axis.
Returns:true if this iterator is a reversed axis.
/** * True if this iterator has a reversed axis. * * @return <code>true</code> if this iterator is a reversed axis. */
public boolean isReverse() { return m_baseIterator.isReverse(); } public void setMark() { m_baseIterator.setMark(); } public void gotoMark() { m_baseIterator.gotoMark(); } }
Iterator that returns children within a given namespace 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).
/** * Iterator that returns children within a given namespace 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 NamespaceChildrenIterator extends InternalAxisIteratorBase {
The extended type ID being requested.
/** The extended type ID being requested. */
private final int _nsType;
Constructor NamespaceChildrenIterator
Params:
  • type – The extended type ID being requested.
/** * Constructor NamespaceChildrenIterator * * * @param type The extended type ID being requested. */
public NamespaceChildrenIterator(final int type) { _nsType = type; }
Set start to END should 'close' the iterator, i.e. subsequent call to next() should return END.
Params:
  • node – Sets the root of the iteration.
Returns:A DTMAxisIterator set to the start of the iteration.
/** * 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 : NOTPROCESSED; return resetPosition(); } return this; }
Get the next node in the iteration.
Returns:The next node handle in the iteration, or END.
/** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */
public int next() { if (_currentNode != DTM.NULL) { for (int node = (NOTPROCESSED == _currentNode) ? _firstch(makeNodeIdentity(_startNode)) : _nextsib(_currentNode); node != END; node = _nextsib(node)) { int nodeHandle = makeNodeHandle(node); if (getNSType(nodeHandle) == _nsType) { _currentNode = node; return returnNode(nodeHandle); } } } return END; } } // end of NamespaceChildrenIterator
Iterator that returns attributes within a given namespace for a node.
/** * Iterator that returns attributes within a given namespace for a node. */
public final class NamespaceAttributeIterator extends InternalAxisIteratorBase {
The extended type ID being requested.
/** The extended type ID being requested. */
private final int _nsType;
Constructor NamespaceAttributeIterator
Params:
  • nsType – The extended type ID being requested.
/** * Constructor NamespaceAttributeIterator * * * @param nsType The extended type ID being requested. */
public NamespaceAttributeIterator(int nsType) { super(); _nsType = nsType; }
Set start to END should 'close' the iterator, i.e. subsequent call to next() should return END.
Params:
  • node – Sets the root of the iteration.
Returns:A DTMAxisIterator set to the start of the iteration.
/** * 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; }
Get the next node in the iteration.
Returns:The next node handle in the iteration, or END.
/** * Get the next node in the iteration. * * @return The next node handle in the iteration, or END. */
public int next() { int node = _currentNode; int nsType = _nsType; int nextNode; if (node == END) { return END; } for (nextNode = getNextAttribute(node); nextNode != END; nextNode = getNextAttribute(nextNode)) { if (getNSType(nextNode) == nsType) { break; } } _currentNode = nextNode; return returnNode(node); } } // end of NamespaceAttributeIterator
Returns an iterator with all descendants of a node that are of a given type.
/** * Returns an iterator with all descendants of a node that are of * a given type. */
public DTMAxisIterator getTypedDescendantIterator(int type) { return new TypedDescendantIterator(type); }
Returns the nth descendant of a node
/** * Returns the nth descendant of a node */
public DTMAxisIterator getNthDescendant(int type, int n, boolean includeself) { return new NthDescendantIterator(n); }
Copy the string value of a node directly to an output handler
/** * Copy the string value of a node directly to an output handler */
public void characters(final int node, SerializationHandler handler) throws TransletException { if (node != DTM.NULL) { try { dispatchCharactersEvents(node, handler, false); } catch (SAXException e) { throw new TransletException(e); } } }
Copy a node-set to an output handler
/** * 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); } }
Copy the whole tree to an output handler
/** * Copy the whole tree to an output handler */
public void copy(SerializationHandler handler) throws TransletException { copy(getDocument(), handler); }
Performs a deep copy (ref. XSLs copy-of()) TODO: Copy namespace declarations. Can't be done until we add namespace nodes and keep track of NS prefixes TODO: Copy comment nodes
/** * Performs a deep copy (ref. XSLs copy-of()) * * TODO: Copy namespace declarations. Can't be done until we * add namespace nodes and keep track of NS prefixes * TODO: Copy comment nodes */
public void copy(final int node, SerializationHandler handler) throws TransletException { copy(node, handler, false ); } private final void copy(final int node, SerializationHandler handler, boolean isChild) throws TransletException { int nodeID = makeNodeIdentity(node); int eType = _exptype2(nodeID); int type = _exptype2Type(eType); try { switch(type) { case DTM.ROOT_NODE: case DTM.DOCUMENT_NODE: for(int c = _firstch2(nodeID); c != DTM.NULL; c = _nextsib2(c)) { copy(makeNodeHandle(c), handler, true); } break; case DTM.PROCESSING_INSTRUCTION_NODE: copyPI(node, handler); break; case DTM.COMMENT_NODE: handler.comment(getStringValueX(node)); break; case DTM.TEXT_NODE: boolean oldEscapeSetting = false; boolean escapeBit = false; if (_dontEscape != null) { escapeBit = _dontEscape.getBit(getNodeIdent(node)); if (escapeBit) { oldEscapeSetting = handler.setEscaping(false); } } copyTextNode(nodeID, handler); if (escapeBit) { handler.setEscaping(oldEscapeSetting); } break; case DTM.ATTRIBUTE_NODE: copyAttribute(nodeID, eType, handler); break; case DTM.NAMESPACE_NODE: handler.namespaceAfterStartElement(getNodeNameX(node), getNodeValue(node)); break; default: if (type == DTM.ELEMENT_NODE) { // Start element definition final String name = copyElement(nodeID, eType, handler); //if(isChild) => not to copy any namespaces from parents // else copy all namespaces in scope copyNS(nodeID, handler,!isChild); copyAttributes(nodeID, handler); // Copy element children for (int c = _firstch2(nodeID); c != DTM.NULL; c = _nextsib2(c)) { copy(makeNodeHandle(c), handler, true); } // Close element definition handler.endElement(name); } // Shallow copy of attribute to output handler else { final String uri = getNamespaceName(node); if (uri.length() != 0) { final String prefix = getPrefix(node); handler.namespaceAfterStartElement(prefix, uri); } handler.addAttribute(getNodeName(node), getNodeValue(node)); } break; } } catch (Exception e) { throw new TransletException(e); } }
Copies a processing instruction node to an output handler
/** * Copies a processing instruction node to an output handler */
private void copyPI(final int node, SerializationHandler handler) throws TransletException { final String target = getNodeName(node); final String value = getStringValueX(node); try { handler.processingInstruction(target, value); } catch (Exception e) { throw new TransletException(e); } }
Performs a shallow copy (ref. XSLs copy())
/** * Performs a shallow copy (ref. XSLs copy()) */
public String shallowCopy(final int node, SerializationHandler handler) throws TransletException { int nodeID = makeNodeIdentity(node); int exptype = _exptype2(nodeID); int type = _exptype2Type(exptype); try { switch(type) { case DTM.ELEMENT_NODE: final String name = copyElement(nodeID, exptype, handler); copyNS(nodeID, handler, true); return name; case DTM.ROOT_NODE: case DTM.DOCUMENT_NODE: return EMPTYSTRING; case DTM.TEXT_NODE: copyTextNode(nodeID, handler); return null; case DTM.PROCESSING_INSTRUCTION_NODE: copyPI(node, handler); return null; case DTM.COMMENT_NODE: handler.comment(getStringValueX(node)); return null; case DTM.NAMESPACE_NODE: handler.namespaceAfterStartElement(getNodeNameX(node), getNodeValue(node)); return null; case DTM.ATTRIBUTE_NODE: copyAttribute(nodeID, exptype, handler); return null; default: final String uri1 = getNamespaceName(node); if (uri1.length() != 0) { final String prefix = getPrefix(node); handler.namespaceAfterStartElement(prefix, uri1); } handler.addAttribute(getNodeName(node), getNodeValue(node)); return null; } } catch (Exception e) { throw new TransletException(e); } }
Returns a node' defined language for a node (if any)
/** * Returns a node' defined language for a node (if any) */
public String getLanguage(int node) { int parent = node; while (DTM.NULL != parent) { if (DTM.ELEMENT_NODE == getNodeType(parent)) { int langAttr = getAttributeNode(parent, "http://www.w3.org/XML/1998/namespace", "lang"); if (DTM.NULL != langAttr) { return getNodeValue(langAttr); } } parent = getParent(parent); } return(null); }
Returns an instance of the DOMBuilder inner class This class will consume the input document through a SAX2 interface and populate the tree.
/** * Returns an instance of the DOMBuilder inner class * This class will consume the input document through a SAX2 * interface and populate the tree. */
public DOMBuilder getBuilder() { return this; }
Return a SerializationHandler for output handling. This method is used by Result Tree Fragments.
/** * Return a SerializationHandler for output handling. * This method is used by Result Tree Fragments. */
public SerializationHandler getOutputDomBuilder() { return new ToXMLSAXHandler(this, "UTF-8"); }
Return a instance of a DOM class to be used as an RTF
/** * Return a instance of a DOM class to be used as an RTF */
public DOM getResultTreeFrag(int initSize, int rtfType) { return getResultTreeFrag(initSize, rtfType, true); }
Return a instance of a DOM class to be used as an RTF
Params:
  • initSize – The initial size of the DOM.
  • rtfType – The type of the RTF
  • addToManager – true if the RTF should be registered with the DTMManager.
Returns:The DOM object which represents the RTF.
/** * Return a instance of a DOM class to be used as an RTF * * @param initSize The initial size of the DOM. * @param rtfType The type of the RTF * @param addToManager true if the RTF should be registered with the DTMManager. * @return The DOM object which represents the RTF. */
public DOM getResultTreeFrag(int initSize, int rtfType, boolean addToManager) { if (rtfType == DOM.SIMPLE_RTF) { if (addToManager) { int dtmPos = _dtmManager.getFirstFreeDTMID(); SimpleResultTreeImpl rtf = new SimpleResultTreeImpl(_dtmManager, dtmPos << DTMManager.IDENT_DTM_NODE_BITS); _dtmManager.addDTM(rtf, dtmPos, 0); return rtf; } else { return new SimpleResultTreeImpl(_dtmManager, 0); } } else if (rtfType == DOM.ADAPTIVE_RTF) { if (addToManager) { int dtmPos = _dtmManager.getFirstFreeDTMID(); AdaptiveResultTreeImpl rtf = new AdaptiveResultTreeImpl(_dtmManager, dtmPos << DTMManager.IDENT_DTM_NODE_BITS, m_wsfilter, initSize, m_buildIdIndex); _dtmManager.addDTM(rtf, dtmPos, 0); return rtf; } else { return new AdaptiveResultTreeImpl(_dtmManager, 0, m_wsfilter, initSize, m_buildIdIndex); } } else { return (DOM) _dtmManager.getDTM(null, true, m_wsfilter, true, false, false, initSize, m_buildIdIndex); } }
Return the attributes map.
Returns:the attributes map.
/** * Return the attributes map. * @return the attributes map. */
public Map<String, Integer> getElementsWithIDs() { return m_idAttributes; }
The getUnparsedEntityURI function returns the URI of the unparsed entity with the specified name in the same document as the context node (see [3.3 Unparsed Entities]). It returns the empty string if there is no such entity.
/** * The getUnparsedEntityURI function returns the URI of the unparsed * entity with the specified name in the same document as the context * node (see [3.3 Unparsed Entities]). It returns the empty string if * there is no such entity. */
public String getUnparsedEntityURI(String name) { // Special handling for DOM input if (_document != null) { String uri = ""; DocumentType doctype = _document.getDoctype(); if (doctype != null) { NamedNodeMap entities = doctype.getEntities(); if (entities == null) { return uri; } Entity entity = (Entity) entities.getNamedItem(name); if (entity == null) { return uri; } String notationName = entity.getNotationName(); if (notationName != null) { uri = entity.getSystemId(); if (uri == null) { uri = entity.getPublicId(); } } } return uri; } else { return super.getUnparsedEntityURI(name); } } public void release() { _dtmManager.release(this, true); } }