905 lines
30 KiB
Java
905 lines
30 KiB
Java
/*
|
|
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.xml.internal.ws.streaming;
|
|
|
|
import com.sun.istack.internal.FinalArrayList;
|
|
import com.sun.istack.internal.NotNull;
|
|
import com.sun.istack.internal.XMLStreamException2;
|
|
import com.sun.xml.internal.ws.util.xml.DummyLocation;
|
|
import com.sun.xml.internal.ws.util.xml.XmlUtil;
|
|
import org.w3c.dom.Attr;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.NamedNodeMap;
|
|
import org.w3c.dom.Node;
|
|
import static org.w3c.dom.Node.*;
|
|
import org.w3c.dom.NodeList;
|
|
import org.w3c.dom.ProcessingInstruction;
|
|
import org.w3c.dom.Text;
|
|
|
|
import javax.xml.namespace.NamespaceContext;
|
|
import javax.xml.namespace.QName;
|
|
import javax.xml.stream.Location;
|
|
import javax.xml.stream.XMLStreamException;
|
|
import javax.xml.stream.XMLStreamReader;
|
|
import javax.xml.transform.dom.DOMSource;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
import java.util.Collections;
|
|
import java.util.Iterator;
|
|
|
|
/**
|
|
* Create an {@link XMLStreamReader} on top of a DOM tree.
|
|
*
|
|
* <p>
|
|
* Since various libraries as well as users often create "incorrect" DOM node,
|
|
* this class spends a lot of efforts making sure that broken DOM trees are
|
|
* nevertheless interpreted correctly.
|
|
*
|
|
* <p>
|
|
* For example, if a DOM level
|
|
* 1 tree is passed, each method will attempt to return the correct value
|
|
* by using {@link Node#getNodeName()}.
|
|
*
|
|
* <p>
|
|
* Similarly, if DOM is missing explicit namespace declarations,
|
|
* this class attempts to emulate necessary declarations.
|
|
*
|
|
*
|
|
* @author Santiago.PericasGeertsen@sun.com
|
|
* @author Kohsuke Kawaguchi
|
|
*/
|
|
public class DOMStreamReader implements XMLStreamReader, NamespaceContext {
|
|
|
|
/**
|
|
* Current DOM node being traversed.
|
|
*/
|
|
protected Node _current;
|
|
|
|
/**
|
|
* Starting node of the subtree being traversed.
|
|
*/
|
|
private Node _start;
|
|
|
|
/**
|
|
* Named mapping for attributes and NS decls for the current node.
|
|
*/
|
|
private NamedNodeMap _namedNodeMap;
|
|
|
|
/**
|
|
* If the reader points at {@link #CHARACTERS the text node},
|
|
* its whole value.
|
|
*
|
|
* <p>
|
|
* This is simply a cache of {@link Text#getWholeText()} of {@link #_current},
|
|
* but when a large binary data sent as base64 text, this could get very much
|
|
* non-trivial.
|
|
*/
|
|
protected String wholeText;
|
|
|
|
/**
|
|
* List of attributes extracted from <code>_namedNodeMap</code>.
|
|
*/
|
|
private final FinalArrayList<Attr> _currentAttributes = new FinalArrayList<Attr>();
|
|
|
|
/**
|
|
* {@link Scope} buffer.
|
|
*/
|
|
protected Scope[] scopes = new Scope[8];
|
|
|
|
/**
|
|
* Depth of the current element. The first element gets depth==0.
|
|
* Also used as the index to {@link #scopes}.
|
|
*/
|
|
protected int depth = 0;
|
|
|
|
/**
|
|
* State of this reader. Any of the valid states defined in StAX'
|
|
* XMLStreamConstants class.
|
|
*/
|
|
protected int _state;
|
|
|
|
/**
|
|
* Namespace declarations on one element.
|
|
*
|
|
* Instances are reused.
|
|
*/
|
|
protected static final class Scope {
|
|
/**
|
|
* Scope for the parent element.
|
|
*/
|
|
final Scope parent;
|
|
|
|
/**
|
|
* List of namespace declarations extracted from <code>_namedNodeMap</code>
|
|
*/
|
|
final FinalArrayList<Attr> currentNamespaces = new FinalArrayList<Attr>();
|
|
|
|
/**
|
|
* Additional namespace declarations obtained as a result of "fixing" DOM tree,
|
|
* which were not part of the original DOM tree.
|
|
*
|
|
* One entry occupies two spaces (prefix followed by URI.)
|
|
*/
|
|
final FinalArrayList<String> additionalNamespaces = new FinalArrayList<String>();
|
|
|
|
Scope(Scope parent) {
|
|
this.parent = parent;
|
|
}
|
|
|
|
void reset() {
|
|
currentNamespaces.clear();
|
|
additionalNamespaces.clear();
|
|
}
|
|
|
|
int getNamespaceCount() {
|
|
return currentNamespaces.size()+additionalNamespaces.size()/2;
|
|
}
|
|
|
|
String getNamespacePrefix(int index) {
|
|
int sz = currentNamespaces.size();
|
|
if(index< sz) {
|
|
Attr attr = currentNamespaces.get(index);
|
|
String result = attr.getLocalName();
|
|
if (result == null) {
|
|
result = QName.valueOf(attr.getNodeName()).getLocalPart();
|
|
}
|
|
return result.equals("xmlns") ? null : result;
|
|
} else {
|
|
return additionalNamespaces.get((index-sz)*2);
|
|
}
|
|
}
|
|
|
|
String getNamespaceURI(int index) {
|
|
int sz = currentNamespaces.size();
|
|
if(index< sz) {
|
|
return currentNamespaces.get(index).getValue();
|
|
} else {
|
|
return additionalNamespaces.get((index-sz)*2+1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the prefix bound to the given URI, or null.
|
|
* This method recurses to the parent.
|
|
*/
|
|
String getPrefix(String nsUri) {
|
|
for( Scope sp=this; sp!=null; sp=sp.parent ) {
|
|
for( int i=sp.currentNamespaces.size()-1; i>=0; i--) {
|
|
String result = getPrefixForAttr(sp.currentNamespaces.get(i),nsUri);
|
|
if(result!=null)
|
|
return result;
|
|
}
|
|
for( int i=sp.additionalNamespaces.size()-2; i>=0; i-=2 )
|
|
if(sp.additionalNamespaces.get(i+1).equals(nsUri))
|
|
return sp.additionalNamespaces.get(i);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the namespace URI bound by the given prefix.
|
|
*
|
|
* @param prefix
|
|
* Prefix to look up.
|
|
*/
|
|
String getNamespaceURI(@NotNull String prefix) {
|
|
String nsDeclName = prefix.length()==0 ? "xmlns" : "xmlns:"+prefix;
|
|
|
|
for( Scope sp=this; sp!=null; sp=sp.parent ) {
|
|
for( int i=sp.currentNamespaces.size()-1; i>=0; i--) {
|
|
Attr a = sp.currentNamespaces.get(i);
|
|
if(a.getNodeName().equals(nsDeclName))
|
|
return a.getValue();
|
|
}
|
|
for( int i=sp.additionalNamespaces.size()-2; i>=0; i-=2 )
|
|
if(sp.additionalNamespaces.get(i).equals(prefix))
|
|
return sp.additionalNamespaces.get(i+1);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public DOMStreamReader() {
|
|
}
|
|
|
|
public DOMStreamReader(Node node) {
|
|
setCurrentNode(node);
|
|
}
|
|
|
|
public void setCurrentNode(Node node) {
|
|
scopes[0] = new Scope(null);
|
|
depth=0;
|
|
|
|
_start = _current = node;
|
|
_state = START_DOCUMENT;
|
|
// verifyDOMIntegrity(node);
|
|
// displayDOM(node, System.out);
|
|
}
|
|
|
|
public void close() throws XMLStreamException {
|
|
}
|
|
|
|
/**
|
|
* Called when the current node is {@link Element} to look at attribute list
|
|
* (which contains both ns decl and attributes in DOM) and split them
|
|
* to attributes-proper and namespace decls.
|
|
*/
|
|
protected void splitAttributes() {
|
|
// Clear attribute and namespace lists
|
|
_currentAttributes.clear();
|
|
|
|
Scope scope = allocateScope();
|
|
|
|
_namedNodeMap = _current.getAttributes();
|
|
if (_namedNodeMap != null) {
|
|
final int n = _namedNodeMap.getLength();
|
|
for (int i = 0; i < n; i++) {
|
|
final Attr attr = (Attr) _namedNodeMap.item(i);
|
|
final String attrName = attr.getNodeName();
|
|
if (attrName.startsWith("xmlns:") || attrName.equals("xmlns")) { // NS decl?
|
|
scope.currentNamespaces.add(attr);
|
|
}
|
|
else {
|
|
_currentAttributes.add(attr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// verify that all the namespaces used in element and attributes are indeed available
|
|
ensureNs(_current);
|
|
for( int i=_currentAttributes.size()-1; i>=0; i-- ) {
|
|
Attr a = _currentAttributes.get(i);
|
|
if(fixNull(a.getNamespaceURI()).length()>0)
|
|
ensureNs(a); // no need to declare "" for attributes in the default namespace
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sub-routine of {@link #splitAttributes()}.
|
|
*
|
|
* <p>
|
|
* Makes sure that the namespace URI/prefix used in the given node is available,
|
|
* and if not, declare it on the current scope to "fix" it.
|
|
*
|
|
* It's often common to create DOM trees without putting namespace declarations,
|
|
* and this makes sure that such DOM tree will be properly marshalled.
|
|
*/
|
|
private void ensureNs(Node n) {
|
|
String prefix = fixNull(n.getPrefix());
|
|
String uri = fixNull(n.getNamespaceURI());
|
|
|
|
Scope scope = scopes[depth];
|
|
|
|
String currentUri = scope.getNamespaceURI(prefix);
|
|
|
|
if(prefix.length()==0) {
|
|
currentUri = fixNull(currentUri);
|
|
if(currentUri.equals(uri))
|
|
return; // declared correctly
|
|
} else {
|
|
if(currentUri!=null && currentUri.equals(uri))
|
|
return; // declared correctly
|
|
}
|
|
|
|
if(prefix.equals("xml") || prefix.equals("xmlns"))
|
|
return; // implicitly declared namespaces
|
|
|
|
// needs to be declared
|
|
scope.additionalNamespaces.add(prefix);
|
|
scope.additionalNamespaces.add(uri);
|
|
}
|
|
|
|
/**
|
|
* Allocate new {@link Scope} for {@link #splitAttributes()}.
|
|
*/
|
|
private Scope allocateScope() {
|
|
if(scopes.length==++depth) {
|
|
Scope[] newBuf = new Scope[scopes.length*2];
|
|
System.arraycopy(scopes,0,newBuf,0,scopes.length);
|
|
scopes = newBuf;
|
|
}
|
|
Scope scope = scopes[depth];
|
|
if(scope==null) {
|
|
scope = scopes[depth] = new Scope(scopes[depth-1]);
|
|
} else {
|
|
scope.reset();
|
|
}
|
|
return scope;
|
|
}
|
|
|
|
public int getAttributeCount() {
|
|
if (_state == START_ELEMENT)
|
|
return _currentAttributes.size();
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeCount() called in illegal state");
|
|
}
|
|
|
|
/**
|
|
* Return an attribute's local name. Handle the case of DOM level 1 nodes.
|
|
*/
|
|
public String getAttributeLocalName(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
String localName = _currentAttributes.get(index).getLocalName();
|
|
return (localName != null) ? localName :
|
|
QName.valueOf(_currentAttributes.get(index).getNodeName()).getLocalPart();
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeLocalName() called in illegal state");
|
|
}
|
|
|
|
/**
|
|
* Return an attribute's qname. Handle the case of DOM level 1 nodes.
|
|
*/
|
|
public QName getAttributeName(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
Node attr = _currentAttributes.get(index);
|
|
String localName = attr.getLocalName();
|
|
if (localName != null) {
|
|
String prefix = attr.getPrefix();
|
|
String uri = attr.getNamespaceURI();
|
|
return new QName(fixNull(uri), localName, fixNull(prefix));
|
|
}
|
|
else {
|
|
return QName.valueOf(attr.getNodeName());
|
|
}
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeName() called in illegal state");
|
|
}
|
|
|
|
public String getAttributeNamespace(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
String uri = _currentAttributes.get(index).getNamespaceURI();
|
|
return fixNull(uri);
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeNamespace() called in illegal state");
|
|
}
|
|
|
|
public String getAttributePrefix(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
String prefix = _currentAttributes.get(index).getPrefix();
|
|
return fixNull(prefix);
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributePrefix() called in illegal state");
|
|
}
|
|
|
|
public String getAttributeType(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
return "CDATA";
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeType() called in illegal state");
|
|
}
|
|
|
|
public String getAttributeValue(int index) {
|
|
if (_state == START_ELEMENT) {
|
|
return _currentAttributes.get(index).getNodeValue();
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeValue() called in illegal state");
|
|
}
|
|
|
|
public String getAttributeValue(String namespaceURI, String localName) {
|
|
if (_state == START_ELEMENT) {
|
|
if (_namedNodeMap != null) {
|
|
Node attr = _namedNodeMap.getNamedItemNS(namespaceURI, localName);
|
|
return attr != null ? attr.getNodeValue() : null;
|
|
}
|
|
return null;
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeValue() called in illegal state");
|
|
}
|
|
|
|
public String getCharacterEncodingScheme() {
|
|
return null;
|
|
}
|
|
|
|
public String getElementText() throws javax.xml.stream.XMLStreamException {
|
|
throw new RuntimeException("DOMStreamReader: getElementText() not implemented");
|
|
}
|
|
|
|
public String getEncoding() {
|
|
return null;
|
|
}
|
|
|
|
public int getEventType() {
|
|
return _state;
|
|
}
|
|
|
|
/**
|
|
* Return an element's local name. Handle the case of DOM level 1 nodes.
|
|
*/
|
|
public String getLocalName() {
|
|
if (_state == START_ELEMENT || _state == END_ELEMENT) {
|
|
String localName = _current.getLocalName();
|
|
return localName != null ? localName :
|
|
QName.valueOf(_current.getNodeName()).getLocalPart();
|
|
}
|
|
else if (_state == ENTITY_REFERENCE) {
|
|
return _current.getNodeName();
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getAttributeValue() called in illegal state");
|
|
}
|
|
|
|
public Location getLocation() {
|
|
return DummyLocation.INSTANCE;
|
|
}
|
|
|
|
/**
|
|
* Return an element's qname. Handle the case of DOM level 1 nodes.
|
|
*/
|
|
public javax.xml.namespace.QName getName() {
|
|
if (_state == START_ELEMENT || _state == END_ELEMENT) {
|
|
String localName = _current.getLocalName();
|
|
if (localName != null) {
|
|
String prefix = _current.getPrefix();
|
|
String uri = _current.getNamespaceURI();
|
|
return new QName(fixNull(uri), localName, fixNull(prefix));
|
|
}
|
|
else {
|
|
return QName.valueOf(_current.getNodeName());
|
|
}
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getName() called in illegal state");
|
|
}
|
|
|
|
public NamespaceContext getNamespaceContext() {
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Verifies the current state to see if we can return the scope, and do so
|
|
* if appropriate.
|
|
*
|
|
* Used to implement a bunch of StAX API methods that have the same usage restriction.
|
|
*/
|
|
private Scope getCheckedScope() {
|
|
if (_state == START_ELEMENT || _state == END_ELEMENT) {
|
|
return scopes[depth];
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: neither on START_ELEMENT nor END_ELEMENT");
|
|
}
|
|
|
|
public int getNamespaceCount() {
|
|
return getCheckedScope().getNamespaceCount();
|
|
}
|
|
|
|
public String getNamespacePrefix(int index) {
|
|
return getCheckedScope().getNamespacePrefix(index);
|
|
}
|
|
|
|
public String getNamespaceURI(int index) {
|
|
return getCheckedScope().getNamespaceURI(index);
|
|
}
|
|
|
|
public String getNamespaceURI() {
|
|
if (_state == START_ELEMENT || _state == END_ELEMENT) {
|
|
String uri = _current.getNamespaceURI();
|
|
return fixNull(uri);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This method is not particularly fast, but shouldn't be called very
|
|
* often. If we start to use it more, we should keep track of the
|
|
* NS declarations using a NamespaceContext implementation instead.
|
|
*/
|
|
public String getNamespaceURI(String prefix) {
|
|
if (prefix == null) {
|
|
throw new IllegalArgumentException("DOMStreamReader: getNamespaceURI(String) call with a null prefix");
|
|
}
|
|
else if (prefix.equals("xml")) {
|
|
return "http://www.w3.org/XML/1998/namespace";
|
|
}
|
|
else if (prefix.equals("xmlns")) {
|
|
return "http://www.w3.org/2000/xmlns/";
|
|
}
|
|
|
|
// check scopes
|
|
String nsUri = scopes[depth].getNamespaceURI(prefix);
|
|
if(nsUri!=null) return nsUri;
|
|
|
|
// then ancestors above start node
|
|
Node node = findRootElement();
|
|
String nsDeclName = prefix.length()==0 ? "xmlns" : "xmlns:"+prefix;
|
|
while (node.getNodeType() != DOCUMENT_NODE) {
|
|
// Is ns declaration on this element?
|
|
NamedNodeMap namedNodeMap = node.getAttributes();
|
|
Attr attr = (Attr) namedNodeMap.getNamedItem(nsDeclName);
|
|
if (attr != null)
|
|
return attr.getValue();
|
|
node = node.getParentNode();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getPrefix(String nsUri) {
|
|
if (nsUri == null) {
|
|
throw new IllegalArgumentException("DOMStreamReader: getPrefix(String) call with a null namespace URI");
|
|
}
|
|
else if (nsUri.equals("http://www.w3.org/XML/1998/namespace")) {
|
|
return "xml";
|
|
}
|
|
else if (nsUri.equals("http://www.w3.org/2000/xmlns/")) {
|
|
return "xmlns";
|
|
}
|
|
|
|
// check scopes
|
|
String prefix = scopes[depth].getPrefix(nsUri);
|
|
if(prefix!=null) return prefix;
|
|
|
|
// then ancestors above start node
|
|
Node node = findRootElement();
|
|
|
|
while (node.getNodeType() != DOCUMENT_NODE) {
|
|
// Is ns declaration on this element?
|
|
NamedNodeMap namedNodeMap = node.getAttributes();
|
|
for( int i=namedNodeMap.getLength()-1; i>=0; i-- ) {
|
|
Attr attr = (Attr)namedNodeMap.item(i);
|
|
prefix = getPrefixForAttr(attr,nsUri);
|
|
if(prefix!=null)
|
|
return prefix;
|
|
}
|
|
node = node.getParentNode();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Finds the root element node of the traversal.
|
|
*/
|
|
private Node findRootElement() {
|
|
int type;
|
|
|
|
Node node = _start;
|
|
while ((type = node.getNodeType()) != DOCUMENT_NODE
|
|
&& type != ELEMENT_NODE) {
|
|
node = node.getParentNode();
|
|
}
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* If the given attribute is a namespace declaration for the given namespace URI,
|
|
* return its prefix. Otherwise null.
|
|
*/
|
|
private static String getPrefixForAttr(Attr attr, String nsUri) {
|
|
String attrName = attr.getNodeName();
|
|
if (!attrName.startsWith("xmlns:") && !attrName.equals("xmlns"))
|
|
return null; // not nsdecl
|
|
|
|
if(attr.getValue().equals(nsUri)) {
|
|
if(attrName.equals("xmlns"))
|
|
return "";
|
|
String localName = attr.getLocalName();
|
|
return (localName != null) ? localName :
|
|
QName.valueOf(attrName).getLocalPart();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Iterator getPrefixes(String nsUri) {
|
|
// This is an incorrect implementation,
|
|
// but AFAIK it's not used in the JAX-WS runtime
|
|
String prefix = getPrefix(nsUri);
|
|
if(prefix==null) return Collections.emptyList().iterator();
|
|
else return Collections.singletonList(prefix).iterator();
|
|
}
|
|
|
|
public String getPIData() {
|
|
if (_state == PROCESSING_INSTRUCTION) {
|
|
return ((ProcessingInstruction) _current).getData();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getPITarget() {
|
|
if (_state == PROCESSING_INSTRUCTION) {
|
|
return ((ProcessingInstruction) _current).getTarget();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getPrefix() {
|
|
if (_state == START_ELEMENT || _state == END_ELEMENT) {
|
|
String prefix = _current.getPrefix();
|
|
return fixNull(prefix);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Object getProperty(String str) throws IllegalArgumentException {
|
|
return null;
|
|
}
|
|
|
|
public String getText() {
|
|
if (_state == CHARACTERS)
|
|
return wholeText;
|
|
if(_state == CDATA || _state == COMMENT || _state == ENTITY_REFERENCE)
|
|
return _current.getNodeValue();
|
|
throw new IllegalStateException("DOMStreamReader: getTextLength() called in illegal state");
|
|
}
|
|
|
|
public char[] getTextCharacters() {
|
|
return getText().toCharArray();
|
|
}
|
|
|
|
public int getTextCharacters(int sourceStart, char[] target, int targetStart,
|
|
int targetLength) throws XMLStreamException {
|
|
String text = getText();
|
|
int copiedSize = Math.min(targetLength, text.length() - sourceStart);
|
|
text.getChars(sourceStart, sourceStart + copiedSize, target, targetStart);
|
|
|
|
return copiedSize;
|
|
}
|
|
|
|
public int getTextLength() {
|
|
return getText().length();
|
|
}
|
|
|
|
public int getTextStart() {
|
|
if (_state == CHARACTERS || _state == CDATA || _state == COMMENT || _state == ENTITY_REFERENCE) {
|
|
return 0;
|
|
}
|
|
throw new IllegalStateException("DOMStreamReader: getTextStart() called in illegal state");
|
|
}
|
|
|
|
public String getVersion() {
|
|
return null;
|
|
}
|
|
|
|
public boolean hasName() {
|
|
return (_state == START_ELEMENT || _state == END_ELEMENT);
|
|
}
|
|
|
|
public boolean hasNext() throws javax.xml.stream.XMLStreamException {
|
|
return (_state != END_DOCUMENT);
|
|
}
|
|
|
|
public boolean hasText() {
|
|
if (_state == CHARACTERS || _state == CDATA || _state == COMMENT || _state == ENTITY_REFERENCE) {
|
|
return getText().trim().length() > 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isAttributeSpecified(int param) {
|
|
return false;
|
|
}
|
|
|
|
public boolean isCharacters() {
|
|
return (_state == CHARACTERS);
|
|
}
|
|
|
|
public boolean isEndElement() {
|
|
return (_state == END_ELEMENT);
|
|
}
|
|
|
|
public boolean isStandalone() {
|
|
return true;
|
|
}
|
|
|
|
public boolean isStartElement() {
|
|
return (_state == START_ELEMENT);
|
|
}
|
|
|
|
public boolean isWhiteSpace() {
|
|
if (_state == CHARACTERS || _state == CDATA)
|
|
return getText().trim().length()==0;
|
|
return false;
|
|
}
|
|
|
|
private static int mapNodeTypeToState(int nodetype) {
|
|
switch (nodetype) {
|
|
case CDATA_SECTION_NODE:
|
|
return CDATA;
|
|
case COMMENT_NODE:
|
|
return COMMENT;
|
|
case ELEMENT_NODE:
|
|
return START_ELEMENT;
|
|
case ENTITY_NODE:
|
|
return ENTITY_DECLARATION;
|
|
case ENTITY_REFERENCE_NODE:
|
|
return ENTITY_REFERENCE;
|
|
case NOTATION_NODE:
|
|
return NOTATION_DECLARATION;
|
|
case PROCESSING_INSTRUCTION_NODE:
|
|
return PROCESSING_INSTRUCTION;
|
|
case TEXT_NODE:
|
|
return CHARACTERS;
|
|
default:
|
|
throw new RuntimeException("DOMStreamReader: Unexpected node type");
|
|
}
|
|
}
|
|
|
|
public int next() throws XMLStreamException {
|
|
while(true) {
|
|
int r = _next();
|
|
switch (r) {
|
|
case CHARACTERS:
|
|
// if we are currently at text node, make sure that this is a meaningful text node.
|
|
Node prev = _current.getPreviousSibling();
|
|
if(prev!=null && prev.getNodeType()==Node.TEXT_NODE)
|
|
continue; // nope. this is just a continuation of previous text that should be invisible
|
|
|
|
Text t = (Text)_current;
|
|
wholeText = t.getWholeText();
|
|
if(wholeText.length()==0)
|
|
continue; // nope. this is empty text.
|
|
return CHARACTERS;
|
|
case START_ELEMENT:
|
|
splitAttributes();
|
|
return START_ELEMENT;
|
|
default:
|
|
return r;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected int _next() throws XMLStreamException {
|
|
Node child;
|
|
|
|
switch (_state) {
|
|
case END_DOCUMENT:
|
|
throw new IllegalStateException("DOMStreamReader: Calling next() at END_DOCUMENT");
|
|
case START_DOCUMENT:
|
|
// Don't skip document element if this is a fragment
|
|
if (_current.getNodeType() == ELEMENT_NODE) {
|
|
return (_state = START_ELEMENT);
|
|
}
|
|
|
|
child = _current.getFirstChild();
|
|
if (child == null) {
|
|
return (_state = END_DOCUMENT);
|
|
}
|
|
else {
|
|
_current = child;
|
|
return (_state = mapNodeTypeToState(_current.getNodeType()));
|
|
}
|
|
case START_ELEMENT:
|
|
child = _current.getFirstChild();
|
|
if (child == null) {
|
|
return (_state = END_ELEMENT);
|
|
}
|
|
else {
|
|
_current = child;
|
|
return (_state = mapNodeTypeToState(_current.getNodeType()));
|
|
}
|
|
case END_ELEMENT:
|
|
depth--;
|
|
// fall through next
|
|
case CHARACTERS:
|
|
case COMMENT:
|
|
case CDATA:
|
|
case ENTITY_REFERENCE:
|
|
case PROCESSING_INSTRUCTION:
|
|
// If at the end of this fragment, then terminate traversal
|
|
if (_current == _start) {
|
|
return (_state = END_DOCUMENT);
|
|
}
|
|
|
|
Node sibling = _current.getNextSibling();
|
|
if (sibling == null) {
|
|
_current = _current.getParentNode();
|
|
// getParentNode() returns null for fragments
|
|
_state = (_current == null || _current.getNodeType() == DOCUMENT_NODE) ?
|
|
END_DOCUMENT : END_ELEMENT;
|
|
return _state;
|
|
}
|
|
else {
|
|
_current = sibling;
|
|
return (_state = mapNodeTypeToState(_current.getNodeType()));
|
|
}
|
|
case DTD:
|
|
case ATTRIBUTE:
|
|
case NAMESPACE:
|
|
default:
|
|
throw new RuntimeException("DOMStreamReader: Unexpected internal state");
|
|
}
|
|
}
|
|
|
|
public int nextTag() throws javax.xml.stream.XMLStreamException {
|
|
int eventType = next();
|
|
while (eventType == CHARACTERS && isWhiteSpace()
|
|
|| eventType == CDATA && isWhiteSpace()
|
|
|| eventType == SPACE
|
|
|| eventType == PROCESSING_INSTRUCTION
|
|
|| eventType == COMMENT)
|
|
{
|
|
eventType = next();
|
|
}
|
|
if (eventType != START_ELEMENT && eventType != END_ELEMENT) {
|
|
throw new XMLStreamException2("DOMStreamReader: Expected start or end tag");
|
|
}
|
|
return eventType;
|
|
}
|
|
|
|
public void require(int type, String namespaceURI, String localName)
|
|
throws javax.xml.stream.XMLStreamException
|
|
{
|
|
if (type != _state) {
|
|
throw new XMLStreamException2("DOMStreamReader: Required event type not found");
|
|
}
|
|
if (namespaceURI != null && !namespaceURI.equals(getNamespaceURI())) {
|
|
throw new XMLStreamException2("DOMStreamReader: Required namespaceURI not found");
|
|
}
|
|
if (localName != null && !localName.equals(getLocalName())) {
|
|
throw new XMLStreamException2("DOMStreamReader: Required localName not found");
|
|
}
|
|
}
|
|
|
|
public boolean standaloneSet() {
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// -- Debugging ------------------------------------------------------
|
|
|
|
private static void displayDOM(Node node, java.io.OutputStream ostream) {
|
|
try {
|
|
System.out.println("\n====\n");
|
|
XmlUtil.newTransformer().transform(
|
|
new DOMSource(node), new StreamResult(ostream));
|
|
System.out.println("\n====\n");
|
|
}
|
|
catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private static void verifyDOMIntegrity(Node node) {
|
|
switch (node.getNodeType()) {
|
|
case ELEMENT_NODE:
|
|
case ATTRIBUTE_NODE:
|
|
|
|
// DOM level 1?
|
|
if (node.getLocalName() == null) {
|
|
System.out.println("WARNING: DOM level 1 node found");
|
|
System.out.println(" -> node.getNodeName() = " + node.getNodeName());
|
|
System.out.println(" -> node.getNamespaceURI() = " + node.getNamespaceURI());
|
|
System.out.println(" -> node.getLocalName() = " + node.getLocalName());
|
|
System.out.println(" -> node.getPrefix() = " + node.getPrefix());
|
|
}
|
|
|
|
if (node.getNodeType() == ATTRIBUTE_NODE) return;
|
|
|
|
NamedNodeMap attrs = node.getAttributes();
|
|
for (int i = 0; i < attrs.getLength(); i++) {
|
|
verifyDOMIntegrity(attrs.item(i));
|
|
}
|
|
case DOCUMENT_NODE:
|
|
NodeList children = node.getChildNodes();
|
|
for (int i = 0; i < children.getLength(); i++) {
|
|
verifyDOMIntegrity(children.item(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private static String fixNull(String s) {
|
|
if(s==null) return "";
|
|
else return s;
|
|
}
|
|
}
|