/*
* Copyright 2004,2005 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.axis2.saaj;
import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder;
import org.apache.axis2.saaj.util.IDGenerator;
import org.apache.axiom.soap.impl.dom.soap11.SOAP11Factory;
import org.apache.axiom.om.util.StAXUtils;
import org.apache.axis2.transport.http.HTTPConstants;
import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.DOMConfiguration;
import org.w3c.dom.DOMException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;
import org.w3c.dom.UserDataHandler;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import javax.xml.soap.SOAPPart;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.Source;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
public class SOAPPartImpl extends SOAPPart {
private Document document;
private SOAPMessage soapMessage;
private SOAPEnvelopeImpl envelope;
private MimeHeadersEx mimeHeaders = new MimeHeadersEx();
private Source source;
public SOAPPartImpl(SOAPMessageImpl parentSoapMsg,
SOAPEnvelopeImpl soapEnvelope) {
setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, IDGenerator.generateID());
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml");
soapMessage = parentSoapMsg;
envelope = soapEnvelope;
document = soapEnvelope.getOwnerDocument();
}
public SOAPPartImpl(SOAPMessageImpl parentSoapMsg,
InputStream inputStream) throws SOAPException {
setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, IDGenerator.generateID());
setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml");
soapMessage = parentSoapMsg;
try {
InputStreamReader isReader = new InputStreamReader(inputStream);
StAXSOAPModelBuilder builder =
new StAXSOAPModelBuilder(StAXUtils.createXMLStreamReader(isReader),
new SOAP11Factory(),
null);
org.apache.axiom.soap.SOAPEnvelope soapEnvelope = builder.getSOAPEnvelope();
envelope = new SOAPEnvelopeImpl((org.apache.axiom.soap.impl.dom.SOAPEnvelopeImpl)soapEnvelope);
envelope.element.build();
this.document = envelope.getOwnerDocument();
} catch (XMLStreamException e) {
e.printStackTrace();
throw new SOAPException(e);
}
}
/**
* Obtain the SOAPMessage
*
* @return the related SOAPMessage
*/
public SOAPMessage getSoapMessage() {
return soapMessage;
}
/**
* Gets the <CODE>SOAPEnvelope</CODE> object associated with
* this <CODE>SOAPPart</CODE> object. Once the SOAP envelope is
* obtained, it can be used to get its contents.
*
* @return the <CODE>SOAPEnvelope</CODE> object for this <CODE>
* SOAPPart</CODE> object
* @throws SOAPException if there is a SOAP error
*/
public SOAPEnvelope getEnvelope() throws SOAPException {
return envelope;
}
/**
* Removes all MIME headers that match the given name.
*
* @param header a <CODE>String</CODE> giving
* the name of the MIME header(s) to be removed
*/
public void removeMimeHeader(String header) {
mimeHeaders.removeHeader(header);
}
/**
* Removes all the <CODE>MimeHeader</CODE> objects for this
* <CODE>SOAPEnvelope</CODE> object.
*/
public void removeAllMimeHeaders() {
mimeHeaders.removeAllHeaders();
}
/**
* Gets all the values of the <CODE>MimeHeader</CODE> object
* in this <CODE>SOAPPart</CODE> object that is identified by
* the given <CODE>String</CODE>.
*
* @param name the name of the header; example:
* "Content-Type"
* @return a <CODE>String</CODE> array giving all the values for
* the specified header
* @see #setMimeHeader(java.lang.String, java.lang.String) setMimeHeader(java.lang.String, java.lang.String)
*/
public String[] getMimeHeader(String name) {
return mimeHeaders.getHeader(name);
}
/**
* Changes the first header entry that matches the given
* header name so that its value is the given value, adding a
* new header with the given name and value if no existing
* header is a match. If there is a match, this method clears
* all existing values for the first header that matches and
* sets the given value instead. If more than one header has
* the given name, this method removes all of the matching
* headers after the first one.
* <p/>
* <P>Note that RFC822 headers can contain only US-ASCII
* characters.</P>
*
* @param name a <CODE>String</CODE> giving the
* header name for which to search
* @param value a <CODE>String</CODE> giving the
* value to be set. This value will be substituted for the
* current value(s) of the first header that is a match if
* there is one. If there is no match, this value will be
* the value for a new <CODE>MimeHeader</CODE> object.
* @throws java.lang.IllegalArgumentException
* if
* there was a problem with the specified mime header name
* or value
* @throws java.lang.IllegalArgumentException
* if there was a problem with the specified mime header name or value
* @see #getMimeHeader(java.lang.String) getMimeHeader(java.lang.String)
*/
public void setMimeHeader(String name, String value) {
mimeHeaders.setHeader(name, value);
}
/**
* Creates a <CODE>MimeHeader</CODE> object with the specified
* name and value and adds it to this <CODE>SOAPPart</CODE>
* object. If a <CODE>MimeHeader</CODE> with the specified
* name already exists, this method adds the specified value
* to the already existing value(s).
* <p/>
* <P>Note that RFC822 headers can contain only US-ASCII
* characters.</P>
*
* @param header a <CODE>String</CODE> giving the
* header name
* @param value a <CODE>String</CODE> giving the
* value to be set or added
* @throws IllegalArgumentException if
* there was a problem with the specified mime header name
* or value
*/
public void addMimeHeader(String header, String value) {
mimeHeaders.addHeader(header, value);
}
/**
* Retrieves all the headers for this <CODE>SOAPPart</CODE>
* object as an iterator over the <CODE>MimeHeader</CODE>
* objects.
*
* @return an <CODE>Iterator</CODE> object with all of the Mime
* headers for this <CODE>SOAPPart</CODE> object
*/
public Iterator getAllMimeHeaders() {
return mimeHeaders.getAllHeaders();
}
/**
* Retrieves all <CODE>MimeHeader</CODE> objects that match
* a name in the given array.
*
* @param names a <CODE>String</CODE> array with
* the name(s) of the MIME headers to be returned
* @return all of the MIME headers that match one of the names
* in the given array, returned as an <CODE>Iterator</CODE>
* object
*/
public Iterator getMatchingMimeHeaders(String[] names) {
return mimeHeaders.getMatchingHeaders(names);
}
/**
* Retrieves all <CODE>MimeHeader</CODE> objects whose name
* does not match a name in the given array.
*
* @param names a <CODE>String</CODE> array with
* the name(s) of the MIME headers not to be returned
* @return all of the MIME headers in this <CODE>SOAPPart</CODE>
* object except those that match one of the names in the
* given array. The nonmatching MIME headers are returned as
* an <CODE>Iterator</CODE> object.
*/
public Iterator getNonMatchingMimeHeaders(String[] names) {
return mimeHeaders.getNonMatchingHeaders(names);
}
/**
* Sets the content of the <CODE>SOAPEnvelope</CODE> object
* with the data from the given <CODE>Source</CODE> object.
*
* @param source javax.xml.transform.Source</CODE> object with the data to
* be set
* @throws SOAPException if there is a problem in
* setting the source
* @see #getContent() getContent()
*/
public void setContent(Source source) throws SOAPException {
this.source = source;
//TODO: Need to fix the source handling stuff
}
/**
* Returns the content of the SOAPEnvelope as a JAXP <CODE>
* Source</CODE> object.
*
* @return the content as a <CODE>
* javax.xml.transform.Source</CODE> object
* @throws SOAPException if the implementation cannot
* convert the specified <CODE>Source</CODE> object
* @see #setContent(javax.xml.transform.Source) setContent(javax.xml.transform.Source)
*/
public Source getContent() throws SOAPException {
return source;
}
/**
* The Document Type Declaration (see <code>DocumentType</code>)
* associated with this document. For HTML documents as well as XML
* documents without a document type declaration this returns
* <code>null</code>. The DOM Level 2 does not support editing the
* Document Type Declaration. <code>docType</code> cannot be altered in
* any way, including through the use of methods inherited from the
* <code>Node</code> interface, such as <code>insertNode</code> or
* <code>removeNode</code>.
*/
public DocumentType getDoctype() {
return document.getDoctype();
}
/**
* The <code>DOMImplementation</code> object that handles this document. A
* DOM application may use objects from multiple implementations.
*/
public DOMImplementation getImplementation() {
return document.getImplementation();
}
/**
* This is a convenience attribute that allows direct access to the child
* node that is the root element of the document. For HTML documents,
* this is the element with the tagName "HTML".
*/
public Element getDocumentElement() {
return document.getDocumentElement();
}
/**
* Creates an element of the type specified. Note that the instance
* returned implements the <code>Element</code> interface, so attributes
* can be specified directly on the returned object.
* <br>In addition, if there are known attributes with default values,
* <code>Attr</code> nodes representing them are automatically created
* and attached to the element.
* <br>To create an element with a qualified name and namespace URI, use
* the <code>createElementNS</code> method.
*
* @param tagName The name of the element type to instantiate. For XML,
* this is case-sensitive. For HTML, the <code>tagName</code>
* parameter may be provided in any case, but it must be mapped to the
* canonical uppercase form by the DOM implementation.
* @return A new <code>Element</code> object with the
* <code>nodeName</code> attribute set to <code>tagName</code>, and
* <code>localName</code>, <code>prefix</code>, and
* <code>namespaceURI</code> set to <code>null</code>.
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*/
public Element createElement(String tagName) throws DOMException {
return document.createElement(tagName);
}
/**
* Creates an empty <code>DocumentFragment</code> object.
*
* @return A new <code>DocumentFragment</code>.
*/
public DocumentFragment createDocumentFragment() {
return document.createDocumentFragment();
}
/**
* Creates a <code>Text</code> node given the specified string.
*
* @param data The data for the node.
* @return The new <code>Text</code> object.
*/
public Text createTextNode(String data) {
return document.createTextNode(data);
}
/**
* Creates a <code>CDATASection</code> node whose value is the specified
* string.
*
* @param data The data for the <code>CDATASection</code> contents.
* @return The new <code>CDATASection</code> object.
* @throws DOMException NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public Comment createComment(String data) {
return document.createComment(data);
}
/**
* Creates a <code>CDATASection</code> node whose value is the specified
* string.
*
* @param data The data for the <code>CDATASection</code> contents.
* @return The new <code>CDATASection</code> object.
* @throws DOMException NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public CDATASection createCDATASection(String data) throws DOMException {
return document.createCDATASection(data);
}
/**
* Creates a <code>ProcessingInstruction</code> node given the specified
* name and data strings.
*
* @param target The target part of the processing instruction.
* @param data The data for the node.
* @return The new <code>ProcessingInstruction</code> object.
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified target contains an
* illegal character.
* <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException {
return document.createProcessingInstruction(target, data);
}
/**
* Creates an <code>Attr</code> of the given name. Note that the
* <code>Attr</code> instance can then be set on an <code>Element</code>
* using the <code>setAttributeNode</code> method.
* <br>To create an attribute with a qualified name and namespace URI, use
* the <code>createAttributeNS</code> method.
*
* @param name The name of the attribute.
* @return A new <code>Attr</code> object with the <code>nodeName</code>
* attribute set to <code>name</code>, and <code>localName</code>,
* <code>prefix</code>, and <code>namespaceURI</code> set to
* <code>null</code>. The value of the attribute is the empty string.
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*/
public Attr createAttribute(String name) throws DOMException {
return document.createAttribute(name);
}
/**
* Creates an <code>EntityReference</code> object. In addition, if the
* referenced entity is known, the child list of the
* <code>EntityReference</code> node is made the same as that of the
* corresponding <code>Entity</code> node.If any descendant of the
* <code>Entity</code> node has an unbound namespace prefix, the
* corresponding descendant of the created <code>EntityReference</code>
* node is also unbound; (its <code>namespaceURI</code> is
* <code>null</code>). The DOM Level 2 does not support any mechanism to
* resolve namespace prefixes.
*
* @param name The name of the entity to reference.
* @return The new <code>EntityReference</code> object.
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public EntityReference createEntityReference(String name) throws DOMException {
return document.createEntityReference(name);
}
/**
* Returns a <code>NodeList</code> of all the <code>Elements</code> with a
* given tag name in the order in which they are encountered in a
* preorder traversal of the <code>Document</code> tree.
*
* @param tagname The name of the tag to match on. The special value "*"
* matches all tags.
* @return A new <code>NodeList</code> object containing all the matched
* <code>Elements</code>.
*/
public NodeList getElementsByTagName(String tagname) {
return document.getElementsByTagName(tagname);
}
/**
* Imports a node from another document to this document. The returned
* node has no parent; (<code>parentNode</code> is <code>null</code>).
* The source node is not altered or removed from the original document;
* this method creates a new copy of the source node.
* <br>For all nodes, importing a node creates a node object owned by the
* importing document, with attribute values identical to the source
* node's <code>nodeName</code> and <code>nodeType</code>, plus the
* attributes related to namespaces (<code>prefix</code>,
* <code>localName</code>, and <code>namespaceURI</code>). As in the
* <code>cloneNode</code> operation on a <code>Node</code>, the source
* node is not altered.
* <br>Additional information is copied as appropriate to the
* <code>nodeType</code>, attempting to mirror the behavior expected if
* a fragment of XML or HTML source was copied from one document to
* another, recognizing that the two documents may have different DTDs
* in the XML case. The following list describes the specifics for each
* type of node.
* <dl>
* <dt>ATTRIBUTE_NODE</dt>
* <dd>The <code>ownerElement</code> attribute
* is set to <code>null</code> and the <code>specified</code> flag is
* set to <code>true</code> on the generated <code>Attr</code>. The
* descendants of the source <code>Attr</code> are recursively imported
* and the resulting nodes reassembled to form the corresponding subtree.
* Note that the <code>deep</code> parameter has no effect on
* <code>Attr</code> nodes; they always carry their children with them
* when imported.</dd>
* <dt>DOCUMENT_FRAGMENT_NODE</dt>
* <dd>If the <code>deep</code> option
* was set to <code>true</code>, the descendants of the source element
* are recursively imported and the resulting nodes reassembled to form
* the corresponding subtree. Otherwise, this simply generates an empty
* <code>DocumentFragment</code>.</dd>
* <dt>DOCUMENT_NODE</dt>
* <dd><code>Document</code>
* nodes cannot be imported.</dd>
* <dt>DOCUMENT_TYPE_NODE</dt>
* <dd><code>DocumentType</code>
* nodes cannot be imported.</dd>
* <dt>ELEMENT_NODE</dt>
* <dd>Specified attribute nodes of the
* source element are imported, and the generated <code>Attr</code>
* nodes are attached to the generated <code>Element</code>. Default
* attributes are not copied, though if the document being imported into
* defines default attributes for this element name, those are assigned.
* If the <code>importNode</code> <code>deep</code> parameter was set to
* <code>true</code>, the descendants of the source element are
* recursively imported and the resulting nodes reassembled to form the
* corresponding subtree.</dd>
* <dt>ENTITY_NODE</dt>
* <dd><code>Entity</code> nodes can be
* imported, however in the current release of the DOM the
* <code>DocumentType</code> is readonly. Ability to add these imported
* nodes to a <code>DocumentType</code> will be considered for addition
* to a future release of the DOM.On import, the <code>publicId</code>,
* <code>systemId</code>, and <code>notationName</code> attributes are
* copied. If a <code>deep</code> import is requested, the descendants
* of the the source <code>Entity</code> are recursively imported and
* the resulting nodes reassembled to form the corresponding subtree.</dd>
* <dt>
* ENTITY_REFERENCE_NODE</dt>
* <dd>Only the <code>EntityReference</code> itself is
* copied, even if a <code>deep</code> import is requested, since the
* source and destination documents might have defined the entity
* differently. If the document being imported into provides a
* definition for this entity name, its value is assigned.</dd>
* <dt>NOTATION_NODE</dt>
* <dd>
* <code>Notation</code> nodes can be imported, however in the current
* release of the DOM the <code>DocumentType</code> is readonly. Ability
* to add these imported nodes to a <code>DocumentType</code> will be
* considered for addition to a future release of the DOM.On import, the
* <code>publicId</code> and <code>systemId</code> attributes are copied.
* Note that the <code>deep</code> parameter has no effect on
* <code>Notation</code> nodes since they never have any children.</dd>
* <dt>
* PROCESSING_INSTRUCTION_NODE</dt>
* <dd>The imported node copies its
* <code>target</code> and <code>data</code> values from those of the
* source node.</dd>
* <dt>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</dt>
* <dd>These three
* types of nodes inheriting from <code>CharacterData</code> copy their
* <code>data</code> and <code>length</code> attributes from those of
* the source node.</dd>
* </dl>
*
* @param importedNode The node to import.
* @param deep If <code>true</code>, recursively import the subtree under
* the specified node; if <code>false</code>, import only the node
* itself, as explained above. This has no effect on <code>Attr</code>
* , <code>EntityReference</code>, and <code>Notation</code> nodes.
* @return The imported node that belongs to this <code>Document</code>.
* @throws DOMException NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
* supported.
* @since DOM Level 2
*/
public Node importNode(Node importedNode, boolean deep) throws DOMException {
return document.importNode(importedNode, deep);
}
/**
* Creates an element of the given qualified name and namespace URI.
*
* @param namespaceURI The namespace URI of the element to create.
* @param qualifiedName The qualified name of the element type to
* instantiate.
* @return A new <code>Element</code> object with the following
* attributes:
* <table border='1' summary="Description of attributes and values for the new Element object">
* <tr>
* <th>Attribute</th>
* <th>Value</th>
* </tr>
* <tr>
* <td valign='top'><code>Node.nodeName</code></td>
* <td valign='top'>
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top'><code>Node.namespaceURI</code></td>
* <td valign='top'>
* <code>namespaceURI</code></td>
* </tr>
* <tr>
* <td valign='top'><code>Node.prefix</code></td>
* <td valign='top'>prefix, extracted
* from <code>qualifiedName</code>, or <code>null</code> if there is
* no prefix</td>
* </tr>
* <tr>
* <td valign='top'><code>Node.localName</code></td>
* <td valign='top'>local name, extracted from
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top'><code>Element.tagName</code></td>
* <td valign='top'>
* <code>qualifiedName</code></td>
* </tr>
* </table>
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name
* contains an illegal character, per the XML 1.0 specification .
* <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
* malformed per the Namespaces in XML specification, if the
* <code>qualifiedName</code> has a prefix and the
* <code>namespaceURI</code> is <code>null</code>, or if the
* <code>qualifiedName</code> has a prefix that is "xml" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/XML/1998/namespace" .
* <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
* support the <code>"XML"</code> feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*/
public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException {
return document.createElementNS(namespaceURI, qualifiedName);
}
/**
* Creates an attribute of the given qualified name and namespace URI.
*
* @param namespaceURI The namespace URI of the attribute to create.
* @param qualifiedName The qualified name of the attribute to
* instantiate.
* @return A new <code>Attr</code> object with the following attributes:
* <table border='1' summary="Description of attributes and values for the new Attr object">
* <tr>
* <th>
* Attribute</th>
* <th>Value</th>
* </tr>
* <tr>
* <td valign='top'><code>Node.nodeName</code></td>
* <td valign='top'>qualifiedName</td>
* </tr>
* <tr>
* <td valign='top'>
* <code>Node.namespaceURI</code></td>
* <td valign='top'><code>namespaceURI</code></td>
* </tr>
* <tr>
* <td valign='top'>
* <code>Node.prefix</code></td>
* <td valign='top'>prefix, extracted from
* <code>qualifiedName</code>, or <code>null</code> if there is no
* prefix</td>
* </tr>
* <tr>
* <td valign='top'><code>Node.localName</code></td>
* <td valign='top'>local name, extracted from
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top'><code>Attr.name</code></td>
* <td valign='top'>
* <code>qualifiedName</code></td>
* </tr>
* <tr>
* <td valign='top'><code>Node.nodeValue</code></td>
* <td valign='top'>the empty
* string</td>
* </tr>
* </table>
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name
* contains an illegal character, per the XML 1.0 specification .
* <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
* malformed per the Namespaces in XML specification, if the
* <code>qualifiedName</code> has a prefix and the
* <code>namespaceURI</code> is <code>null</code>, if the
* <code>qualifiedName</code> has a prefix that is "xml" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/XML/1998/namespace", or if the
* <code>qualifiedName</code>, or its prefix, is "xmlns" and the
* <code>namespaceURI</code> is different from "
* http://www.w3.org/2000/xmlns/".
* <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
* support the <code>"XML"</code> feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*/
public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException {
return document.createAttributeNS(namespaceURI, qualifiedName);
}
/**
* Returns a <code>NodeList</code> of all the <code>Elements</code> with a
* given local name and namespace URI in the order in which they are
* encountered in a preorder traversal of the <code>Document</code> tree.
*
* @param namespaceURI The namespace URI of the elements to match on. The
* special value "*" matches all namespaces.
* @param localName The local name of the elements to match on. The
* special value "*" matches all local names.
* @return A new <code>NodeList</code> object containing all the matched
* <code>Elements</code>.
* @since DOM Level 2
*/
public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
return document.getElementsByTagNameNS(namespaceURI, localName);
}
/**
* Returns the <code>Element</code> whose <code>ID</code> is given by
* <code>elementId</code>. If no such element exists, returns
* <code>null</code>. Behavior is not defined if more than one element
* has this <code>ID</code>. The DOM implementation must have
* information that says which attributes are of type ID. Attributes
* with the name "ID" are not of type ID unless so defined.
* Implementations that do not know whether attributes are of type ID or
* not are expected to return <code>null</code>.
*
* @param elementId The unique <code>id</code> value for an element.
* @return The matching element.
* @since DOM Level 2
*/
public Element getElementById(String elementId) {
return document.getElementById(elementId);
}
public String getInputEncoding() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String getXmlEncoding() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public boolean getXmlStandalone() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String getXmlVersion() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void setXmlVersion(String xmlVersion) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public boolean getStrictErrorChecking() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void setStrictErrorChecking(boolean strictErrorChecking) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String getDocumentURI() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void setDocumentURI(String documentURI) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public Node adoptNode(Node source) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public DOMConfiguration getDomConfig() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void normalizeDocument() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
/**
* The name of this node, depending on its type; see the table above.
*/
public String getNodeName() {
return document.getNodeName();
}
/**
* The value of this node, depending on its type; see the table above.
* When it is defined to be <code>null</code>, setting it has no effect.
*
* @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @throws DOMException DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a <code>DOMString</code> variable on the implementation
* platform.
*/
public String getNodeValue() throws DOMException {
return document.getNodeValue();
}
/**
* The value of this node, depending on its type; see the table above.
* When it is defined to be <code>null</code>, setting it has no effect.
*
* @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @throws DOMException DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a <code>DOMString</code> variable on the implementation
* platform.
*/
public void setNodeValue(String arg0) throws DOMException {
document.setNodeValue(arg0);
}
/**
* A code representing the type of the underlying object, as defined above.
*/
public short getNodeType() {
return document.getNodeType();
}
/**
* The parent of this node. All nodes, except <code>Attr</code>,
* <code>Document</code>, <code>DocumentFragment</code>,
* <code>Entity</code>, and <code>Notation</code> may have a parent.
* However, if a node has just been created and not yet added to the
* tree, or if it has been removed from the tree, this is
* <code>null</code>.
*/
public Node getParentNode() {
return document.getParentNode();
}
/**
* A <code>NodeList</code> that contains all children of this node. If
* there are no children, this is a <code>NodeList</code> containing no
* nodes.
*/
public NodeList getChildNodes() {
return document.getChildNodes();
}
/**
* The first child of this node. If there is no such node, this returns
* <code>null</code>.
*/
public Node getFirstChild() {
return document.getFirstChild();
}
/**
* The last child of this node. If there is no such node, this returns
* <code>null</code>.
*/
public Node getLastChild() {
return document.getLastChild();
}
/**
* The node immediately preceding this node. If there is no such node,
* this returns <code>null</code>.
*/
public Node getPreviousSibling() {
return document.getPreviousSibling();
}
/**
* The node immediately following this node. If there is no such node,
* this returns <code>null</code>.
*/
public Node getNextSibling() {
return document.getNextSibling();
}
/**
* A <code>NamedNodeMap</code> containing the attributes of this node (if
* it is an <code>Element</code>) or <code>null</code> otherwise.
*/
public NamedNodeMap getAttributes() {
return document.getAttributes();
}
/**
* The <code>Document</code> object associated with this node. This is
* also the <code>Document</code> object used to create new nodes. When
* this node is a <code>Document</code> or a <code>DocumentType</code>
* which is not used with any <code>Document</code> yet, this is
* <code>null</code>.
*/
public Document getOwnerDocument() {
return document.getOwnerDocument();
}
/**
* Inserts the node <code>newChild</code> before the existing child node
* <code>refChild</code>. If <code>refChild</code> is <code>null</code>,
* insert <code>newChild</code> at the end of the list of children.
* <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
* all of its children are inserted, in the same order, before
* <code>refChild</code>. If the <code>newChild</code> is already in the
* tree, it is first removed.
*
* @param newChild The node to insert.
* @param refChild The reference node, i.e., the node before which the
* new node must be inserted.
* @return The node being inserted.
* @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to insert is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
* if the parent of the node being inserted is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>refChild</code> is not a child of
* this node.
*/
public Node insertBefore(Node newChild, Node refChild) throws DOMException {
return document.insertBefore(newChild, refChild);
}
/**
* Replaces the child node <code>oldChild</code> with <code>newChild</code>
* in the list of children, and returns the <code>oldChild</code> node.
* <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
* <code>oldChild</code> is replaced by all of the
* <code>DocumentFragment</code> children, which are inserted in the
* same order. If the <code>newChild</code> is already in the tree, it
* is first removed.
*
* @param newChild The new node to put in the child list.
* @param oldChild The node being replaced in the list.
* @return The node replaced.
* @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to put in is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of
* the new node is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
* this node.
*/
public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
return document.replaceChild(newChild, oldChild);
}
/**
* Removes the child node indicated by <code>oldChild</code> from the list
* of children, and returns it.
*
* @param oldChild The node being removed.
* @return The node removed.
* @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
* this node.
*/
public Node removeChild(Node oldChild) throws DOMException {
return document.removeChild(oldChild);
}
/**
* Adds the node <code>newChild</code> to the end of the list of children
* of this node. If the <code>newChild</code> is already in the tree, it
* is first removed.
*
* @param newChild The node to add.If it is a
* <code>DocumentFragment</code> object, the entire contents of the
* document fragment are moved into the child list of this node
* @return The node added.
* @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
* allow children of the type of the <code>newChild</code> node, or if
* the node to append is one of this node's ancestors or this node
* itself.
* <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
* from a different document than the one that created this node.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
* if the previous parent of the node being inserted is readonly.
*/
public Node appendChild(Node newChild) throws DOMException {
return document.appendChild(newChild);
}
/**
* Returns whether this node has any children.
*
* @return <code>true</code> if this node has any children,
* <code>false</code> otherwise.
*/
public boolean hasChildNodes() {
return document.hasChildNodes();
}
/**
* Returns a duplicate of this node, i.e., serves as a generic copy
* constructor for nodes. The duplicate node has no parent; (
* <code>parentNode</code> is <code>null</code>.).
* <br>Cloning an <code>Element</code> copies all attributes and their
* values, including those generated by the XML processor to represent
* defaulted attributes, but this method does not copy any text it
* contains unless it is a deep clone, since the text is contained in a
* child <code>Text</code> node. Cloning an <code>Attribute</code>
* directly, as opposed to be cloned as part of an <code>Element</code>
* cloning operation, returns a specified attribute (
* <code>specified</code> is <code>true</code>). Cloning any other type
* of node simply returns a copy of this node.
* <br>Note that cloning an immutable subtree results in a mutable copy,
* but the children of an <code>EntityReference</code> clone are readonly
* . In addition, clones of unspecified <code>Attr</code> nodes are
* specified. And, cloning <code>Document</code>,
* <code>DocumentType</code>, <code>Entity</code>, and
* <code>Notation</code> nodes is implementation dependent.
*
* @param deep If <code>true</code>, recursively clone the subtree under
* the specified node; if <code>false</code>, clone only the node
* itself (and its attributes, if it is an <code>Element</code>).
* @return The duplicate node.
*/
public Node cloneNode(boolean deep) {
return document.cloneNode(deep);
}
/**
* Puts all <code>Text</code> nodes in the full depth of the sub-tree
* underneath this <code>Node</code>, including attribute nodes, into a
* "normal" form where only structure (e.g., elements, comments,
* processing instructions, CDATA sections, and entity references)
* separates <code>Text</code> nodes, i.e., there are neither adjacent
* <code>Text</code> nodes nor empty <code>Text</code> nodes. This can
* be used to ensure that the DOM view of a document is the same as if
* it were saved and re-loaded, and is useful when operations (such as
* XPointer lookups) that depend on a particular document tree
* structure are to be used.In cases where the document contains
* <code>CDATASections</code>, the normalize operation alone may not be
* sufficient, since XPointers do not differentiate between
* <code>Text</code> nodes and <code>CDATASection</code> nodes.
*/
public void normalize() {
document.normalize();
}
/**
* Tests whether the DOM implementation implements a specific feature and
* that feature is supported by this node.
*
* @param feature The name of the feature to test. This is the same name
* which can be passed to the method <code>hasFeature</code> on
* <code>DOMImplementation</code>.
* @param version This is the version number of the feature to test. In
* Level 2, version 1, this is the string "2.0". If the version is not
* specified, supporting any version of the feature will cause the
* method to return <code>true</code>.
* @return Returns <code>true</code> if the specified feature is
* supported on this node, <code>false</code> otherwise.
* @since DOM Level 2
*/
public boolean isSupported(String feature, String version) {
return document.isSupported(feature, version);
}
/**
* The namespace URI of this node, or <code>null</code> if it is
* unspecified.
* <br>This is not a computed value that is the result of a namespace
* lookup based on an examination of the namespace declarations in
* scope. It is merely the namespace URI given at creation time.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.Per
* the Namespaces in XML Specification an attribute does not inherit
* its namespace from the element it is attached to. If an attribute is
* not explicitly given a namespace, it simply has no namespace.
*
* @since DOM Level 2
*/
public String getNamespaceURI() {
return document.getNamespaceURI();
}
/**
* The namespace prefix of this node, or <code>null</code> if it is
* unspecified.
* <br>Note that setting this attribute, when permitted, changes the
* <code>nodeName</code> attribute, which holds the qualified name, as
* well as the <code>tagName</code> and <code>name</code> attributes of
* the <code>Element</code> and <code>Attr</code> interfaces, when
* applicable.
* <br>Note also that changing the prefix of an attribute that is known to
* have a default value, does not make a new attribute with the default
* value and the original prefix appear, since the
* <code>namespaceURI</code> and <code>localName</code> do not change.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
*
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
* illegal character, per the XML 1.0 specification .
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI</code> of this node is <code>null</code>, if the
* specified prefix is "xml" and the <code>namespaceURI</code> of this
* node is different from "http://www.w3.org/XML/1998/namespace", if
* this node is an attribute and the specified prefix is "xmlns" and
* the <code>namespaceURI</code> of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and
* the <code>qualifiedName</code> of this node is "xmlns" .
* @since DOM Level 2
*/
public String getPrefix() {
return document.getPrefix();
}
/**
* The namespace prefix of this node, or <code>null</code> if it is
* unspecified.
* <br>Note that setting this attribute, when permitted, changes the
* <code>nodeName</code> attribute, which holds the qualified name, as
* well as the <code>tagName</code> and <code>name</code> attributes of
* the <code>Element</code> and <code>Attr</code> interfaces, when
* applicable.
* <br>Note also that changing the prefix of an attribute that is known to
* have a default value, does not make a new attribute with the default
* value and the original prefix appear, since the
* <code>namespaceURI</code> and <code>localName</code> do not change.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
*
* @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
* illegal character, per the XML 1.0 specification .
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
* <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI</code> of this node is <code>null</code>, if the
* specified prefix is "xml" and the <code>namespaceURI</code> of this
* node is different from "http://www.w3.org/XML/1998/namespace", if
* this node is an attribute and the specified prefix is "xmlns" and
* the <code>namespaceURI</code> of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and
* the <code>qualifiedName</code> of this node is "xmlns" .
* @since DOM Level 2
*/
public void setPrefix(String arg0) throws DOMException {
document.setPrefix(arg0);
}
/**
* Returns the local part of the qualified name of this node.
* <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
* <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
* method, such as <code>createElement</code> from the
* <code>Document</code> interface, this is always <code>null</code>.
*
* @since DOM Level 2
*/
public String getLocalName() {
return document.getLocalName();
}
/**
* Returns whether this node (if it is an element) has any attributes.
*
* @return <code>true</code> if this node has any attributes,
* <code>false</code> otherwise.
* @since DOM Level 2
*/
public boolean hasAttributes() {
return document.hasAttributes();
}
protected void setMessage(SOAPMessageImpl message) {
soapMessage = message;
}
/*
* DOM-Level 3 methods
*/
public String getBaseURI() {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public short compareDocumentPosition(Node arg0) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String getTextContent() throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public void setTextContent(String arg0) throws DOMException {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public boolean isSameNode(Node arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String lookupPrefix(String arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public boolean isDefaultNamespace(String arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public String lookupNamespaceURI(String arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public boolean isEqualNode(Node arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public Object getFeature(String arg0, String arg1) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public Object setUserData(String arg0, Object arg1, UserDataHandler arg2) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
public Object getUserData(String arg0) {
// TODO TODO
throw new UnsupportedOperationException("TODO");
}
}