Axis 2 example source code file (SOAPPartImpl.java)
The Axis 2 SOAPPartImpl.java source code
/*
* 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 org.apache.axis2.saaj;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
import javax.xml.soap.MimeHeader;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPElement;
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.stream.XMLStreamReader;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.apache.axiom.attachments.Attachments;
import org.apache.axiom.om.impl.MTOMConstants;
import org.apache.axiom.om.util.StAXUtils;
import org.apache.axiom.soap.SOAP11Constants;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axiom.soap.impl.builder.MTOMStAXSOAPModelBuilder;
import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder;
import org.apache.axiom.soap.impl.dom.soap11.SOAP11Factory;
import org.apache.axiom.soap.impl.dom.soap12.SOAP12Factory;
import org.apache.axis2.builder.BuilderUtil;
import org.apache.axis2.saaj.util.IDGenerator;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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;
public class SOAPPartImpl extends SOAPPart {
private static final Log log = LogFactory.getLog(SOAPPartImpl.class);
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");
this.mimeHeaders = (MimeHeadersEx)parentSoapMsg.getMimeHeaders();
soapMessage = parentSoapMsg;
envelope = soapEnvelope;
document = soapEnvelope.getOwnerDocument();
}
public SOAPPartImpl(SOAPMessageImpl parentSoapMsg,
InputStream inputStream, javax.xml.soap.MimeHeaders mimeHeaders
) throws SOAPException {
String contentType = "";
String fullContentTypeStr = "";
if (mimeHeaders == null) {
//TODO : read string from constants
mimeHeaders = new MimeHeaders();
mimeHeaders.addHeader("Content-ID", IDGenerator.generateID());
mimeHeaders.addHeader("content-type", HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML);
} else {
String contentTypes[] = mimeHeaders.getHeader(HTTPConstants.CONTENT_TYPE);
if (contentTypes != null && contentTypes.length > 0) {
fullContentTypeStr = contentTypes[0];
contentType = extractFirstPart(fullContentTypeStr);
}
}
Iterator mimeHeaderIterator = mimeHeaders.getAllHeaders();
while (mimeHeaderIterator.hasNext()) {
MimeHeader mimeHeader = (MimeHeader)mimeHeaderIterator.next();
String value = mimeHeader.getValue();
setMimeHeader(mimeHeader.getName(), value);
}
soapMessage = parentSoapMsg;
String knownEncoding = (String) soapMessage.getProperty(SOAPMessage.CHARACTER_SET_ENCODING);
XMLStreamReader xmlReader = null;
InputStream modifiedInputStream = null;
StAXSOAPModelBuilder builder = null;
InputStreamReader isReader = null;
if (contentType.indexOf("multipart/related") == 0) {
//This contains attachements
try {
Attachments attachments =
new Attachments(inputStream, fullContentTypeStr, false, "", "");
modifiedInputStream = attachments.getSOAPPartInputStream();
isReader = new InputStreamReader(modifiedInputStream);
String soapEnvelopeNamespaceURI =
BuilderUtil.getEnvelopeNamespace(fullContentTypeStr);
String charSetEncoding =
BuilderUtil.getCharSetEncoding(attachments.getSOAPPartContentType());
XMLStreamReader streamReader =
StAXUtils.createXMLStreamReader(BuilderUtil.getReader(
attachments.getSOAPPartInputStream(), charSetEncoding));
SOAPFactory factory;
if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(soapEnvelopeNamespaceURI)) {
factory = new SOAP11Factory();
} else {
factory = new SOAP12Factory();
}
if (attachments.getAttachmentSpecType().equals(
MTOMConstants.MTOM_TYPE)) {
//Creates the MTOM specific MTOMStAXSOAPModelBuilder
builder = new MTOMStAXSOAPModelBuilder(streamReader,
factory,
attachments,
soapEnvelopeNamespaceURI);
} else if (attachments.getAttachmentSpecType().equals(
MTOMConstants.SWA_TYPE)) {
builder = new StAXSOAPModelBuilder(streamReader,
factory,
soapEnvelopeNamespaceURI);
} else if (attachments.getAttachmentSpecType().equals(
MTOMConstants.SWA_TYPE_12)) {
builder = new StAXSOAPModelBuilder(streamReader,
factory,
soapEnvelopeNamespaceURI);
}
} catch (Exception e) {
throw new SOAPException(e);
}
} else {
modifiedInputStream = inputStream;
try {
isReader = new InputStreamReader(modifiedInputStream);
XMLStreamReader streamReader = null;
if(knownEncoding != null){
streamReader = StAXUtils.createXMLStreamReader(modifiedInputStream, knownEncoding);
}else{
streamReader = StAXUtils.createXMLStreamReader(modifiedInputStream);
}
if (HTTPConstants.MEDIA_TYPE_TEXT_XML.equals(contentType)) {
builder = new StAXSOAPModelBuilder(streamReader,
new SOAP11Factory(),
SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
} else if (HTTPConstants.MEDIA_TYPE_APPLICATION_SOAP_XML.equals(contentType)) {
builder = new StAXSOAPModelBuilder(streamReader,
new SOAP12Factory(),
SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
} else if (HTTPConstants.MEDIA_TYPE_MULTIPART_RELATED.equals(contentType)) {
builder = new StAXSOAPModelBuilder(streamReader,
new SOAP11Factory(),
null);
} else {
builder = new StAXSOAPModelBuilder(streamReader,
new SOAP11Factory(),
null);
}
} catch (XMLStreamException e) {
throw new SOAPException(e);
}
}
try {
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();
javax.xml.transform.Source xmlSource =
new javax.xml.transform.stream.StreamSource( isReader);
this.source = xmlSource;
} catch (Exception e) {
throw new SOAPException(e);
}
}
private String extractFirstPart(String fullContentTypeStr) {
String contentType;//tmpContentType can be like 'application/soap+xml; charset=UTF-8;'
//Only the first part is important
if (fullContentTypeStr.indexOf(";") > -1) {
contentType = fullContentTypeStr.substring(0, fullContentTypeStr.indexOf(";"));
} else {
contentType = fullContentTypeStr;
}
return contentType;
}
public SOAPPartImpl(SOAPMessageImpl parentSoapMsg,
InputStream inputStream) throws SOAPException {
this(parentSoapMsg, inputStream, null);
}
/**
* Obtain the SOAPMessage
*
* @return the related SOAPMessage
*/
public SOAPMessage getSoapMessage() {
return soapMessage;
}
/**
* Gets the <CODE>SOAPEnvelope object associated with this null and the
* <code>specified flag is set to true on the generated Attr.
* The descendants of the source <code>Attr are recursively imported and the resulting
* nodes reassembled to form the corresponding subtree. Note that the <code>deep
* parameter has no effect on <code>Attr nodes; they always carry their children with
* them when imported.</dd> deep option
* was set to <code>true, 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.Document nodes cannot be imported. DocumentType nodes cannot be imported. Element. 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>deep parameter was set to true, the descendants of the source
* element are recursively imported and the resulting nodes reassembled to form the
* corresponding subtree.</dd> Entity nodes can be
* imported, however in the current release of the DOM the <code>DocumentType is
* readonly. Ability to add these imported nodes to a <code>DocumentType will be
* considered for addition to a future release of the DOM.On import, the <code>publicId,
* <code>systemId, and notationName attributes are copied. If a
* <code>deep import is requested, the descendants of the the source Entity
* are recursively imported and the resulting nodes reassembled to form the corresponding
* subtree.</dd> EntityReference
* itself is copied, even if a <code>deep 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 Notation nodes can be imported, however in the
* current release of the DOM the <code>DocumentType is readonly. Ability to add these
* imported nodes to a <code>DocumentType will be considered for addition to a future
* release of the DOM.On import, the <code>publicId and systemId attributes
* are copied. Note that the <code>deep parameter has no effect on Notation
* nodes since they never have any children.</dd> data values from those of the
* source node.</dd> data and
* <code>length attributes from those of the source node.EntityReference,
* and <code>Notation nodes.
* @return The imported node that belongs to this <code>Document.
* @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 object with the following attributes:
null, or if the
* <code>qualifiedName has a prefix that is "xml" and the
* <code>namespaceURI 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" 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 object with the following attributes:
null, if the
* <code>qualifiedName has a prefix that is "xml" and the
* <code>namespaceURI is different from " http://www.w3.org/XML/1998/namespace",
* or if the <code>qualifiedName, or its prefix, is "xmlns" and the
* <code>namespaceURI 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" 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 of all the Elements with a given local name and
* namespace URI in the order in which they are encountered in a preorder traversal of the
* <code>Document 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 object containing all the matched Elements.
* @since DOM Level 2
*/
public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
return document.getElementsByTagNameNS(namespaceURI, localName);
}
/**
* Returns the <code>Element whose ID is given by elementId. If
* no such element exists, returns <code>null. Behavior is not defined if more than one
* element has this <code>ID. 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.
*
* @param elementId The unique <code>id value for an element.
* @return The matching element.
* @since DOM Level 2
*/
public Element getElementById(String elementId) {
return document.getElementById(elementId);
}
public String getInputEncoding() {
//return ((DeferredDocumentImpl)(((DOMSource)this.source).getNode())).getInputEncoding();
return this.envelope.getEncodingStyle();
}
public String getXmlEncoding() {
return document.getXmlEncoding();
}
public boolean getXmlStandalone() {
return document.getXmlStandalone();
}
public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
document.setXmlStandalone(xmlStandalone);
}
public String getXmlVersion() {
return document.getXmlVersion();
}
public void setXmlVersion(String xmlVersion) throws DOMException {
document.setXmlVersion(xmlVersion);
}
public boolean getStrictErrorChecking() {
return document.getStrictErrorChecking();
}
public void setStrictErrorChecking(boolean strictErrorChecking) {
document.setStrictErrorChecking(strictErrorChecking);
}
public String getDocumentURI() {
return document.getDocumentURI();
}
public void setDocumentURI(String documentURI) {
document.setDocumentURI(documentURI);
}
public Node adoptNode(Node source) throws DOMException {
return document.adoptNode(source);
}
public DOMConfiguration getDomConfig() {
return document.getDomConfig();
}
public void normalizeDocument() {
document.normalizeDocument();
}
public Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
return document.renameNode(n, namespaceURI, qualifiedName);
}
/** 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, 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 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, 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 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, Document,
* <code>DocumentFragment, Entity, and Notation 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.
*/
public Node getParentNode() {
return document.getParentNode();
}
/**
* A <code>NodeList that contains all children of this node. If there are no children,
* this is a <code>NodeList 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. */
public Node getFirstChild() {
return document.getFirstChild();
}
/** The last child of this node. If there is no such node, this returns <code>null. */
public Node getLastChild() {
return document.getLastChild();
}
/**
* The node immediately preceding this node. If there is no such node, this returns
* <code>null.
*/
public Node getPreviousSibling() {
return document.getPreviousSibling();
}
/**
* The node immediately following this node. If there is no such node, this returns
* <code>null.
*/
public Node getNextSibling() {
return document.getNextSibling();
}
/**
* A <code>NamedNodeMap containing the attributes of this node (if it is an
* <code>Element) or null otherwise.
*/
public NamedNodeMap getAttributes() {
return document.getAttributes();
}
/**
* The <code>Document object associated with this node. This is also the
* <code>Document object used to create new nodes. When this node is a
* <code>Document or a DocumentType which is not used with any
* <code>Document yet, this is null.
*/
public Document getOwnerDocument() {
return document.getOwnerDocument();
}
/**
* Inserts the node <code>newChild before the existing child node refChild.
* If <code>refChild is null, insert newChild at the end of the
* list of children. <br>If newChild is a DocumentFragment object, all
* of its children are inserted, in the same order, before <code>refChild. If the
* <code>newChild 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 node, or if the
* node to insert is one of this node's ancestors or this node itself.
* <br>WRONG_DOCUMENT_ERR: Raised if newChild 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 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 with newChild in the list of
* children, and returns the <code>oldChild node. If newChild is a
* <code>DocumentFragment object, oldChild is replaced by all of the
* <code>DocumentFragment children, which are inserted in the same order. If the
* <code>newChild 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 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 newChild 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 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 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 oldChild is not a child of
* this node.
*/
public Node removeChild(Node oldChild) throws DOMException {
return document.removeChild(oldChild);
}
/**
* Adds the node <code>newChild to the end of the list of children of this node. If the
* <code>newChild is already in the tree, it is first removed.
*
* @param newChild The node to add.If it is a <code>DocumentFragment 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 node, or if the
* node to append is one of this node's ancestors or this node itself.
* <br>WRONG_DOCUMENT_ERR: Raised if newChild 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 if this node has any children, false 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 is null.). Cloning * an <code>Element 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 node. Cloning an Attribute directly, as opposed to be cloned
* as part of an <code>Element cloning operation, returns a specified attribute (
* <code>specified is true). 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 clone are readonly . In addition, clones of
* unspecified <code>Attr nodes are specified. And, cloning Document,
* <code>DocumentType, Entity, and Notation nodes is
* implementation dependent.
*
* @param deep If <code>true, recursively clone the subtree under the specified node; if
* <code>false, clone only the node itself (and its attributes, if it is an
* <code>Element).
* @return The duplicate node.
*/
public Node cloneNode(boolean deep) {
return document.cloneNode(deep);
}
/**
* Puts all <code>Text nodes in the full depth of the sub-tree underneath this
* <code>Node, including attribute nodes, into a "normal" form where only structure
* (e.g., elements, comments, processing instructions, CDATA sections, and entity references)
* separates <code>Text nodes, i.e., there are neither adjacent Text nodes
* nor empty <code>Text 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, the normalize operation alone
* may not be sufficient, since XPointers do not differentiate between <code>Text nodes
* and <code>CDATASection 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 on DOMImplementation.
* @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.
* @return Returns <code>true if the specified feature is supported on this node,
* <code>false 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 if it is unspecified. 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 ELEMENT_NODE and
* <code>ATTRIBUTE_NODE and nodes created with a DOM Level 1 method, such as
* <code>createElement from the Document interface, this is always
* <code>null.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 if it is unspecified. Note that * setting this attribute, when permitted, changes the <code>nodeName attribute, which * holds the qualified name, as well as the <code>tagName and name
* attributes of the <code>Element and Attr 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 and localName do not change. For nodes of any * type other than <code>ELEMENT_NODE and ATTRIBUTE_NODE and nodes created
* with a DOM Level 1 method, such as <code>createElement from the Document
* interface, this is always <code>null.
*
* @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 prefix is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI of this node is null, if the
* specified prefix is "xml" and the <code>namespaceURI 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 of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and the
* <code>qualifiedName of this node is "xmlns" .
* @since DOM Level 2
*/
public String getPrefix() {
return document.getPrefix();
}
/**
* The namespace prefix of this node, or <code>null if it is unspecified. Note that * setting this attribute, when permitted, changes the <code>nodeName attribute, which * holds the qualified name, as well as the <code>tagName and name
* attributes of the <code>Element and Attr 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 and localName do not change. For nodes of any * type other than <code>ELEMENT_NODE and ATTRIBUTE_NODE and nodes created
* with a DOM Level 1 method, such as <code>createElement from the Document
* interface, this is always <code>null.
*
* @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 prefix is
* malformed per the Namespaces in XML specification, if the
* <code>namespaceURI of this node is null, if the
* specified prefix is "xml" and the <code>namespaceURI 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 of this node is different from "
* http://www.w3.org/2000/xmlns/", or if this node is an attribute and the
* <code>qualifiedName 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 and ATTRIBUTE_NODE and nodes created with a DOM
* Level 1 method, such as <code>createElement from the Document interface,
* this is always <code>null.
*
* @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 if this node has any attributes, false 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() {
return document.getBaseURI();
}
public short compareDocumentPosition(Node node) throws DOMException {
return document.compareDocumentPosition(node);
}
public String getTextContent() throws DOMException {
return document.getTextContent();
}
public void setTextContent(String textContent) throws DOMException {
document.setTextContent(textContent);
}
public boolean isSameNode(Node other) {
return document.isSameNode(other);
}
public String lookupPrefix(String namespaceURI) {
return document.lookupPrefix(namespaceURI);
}
public boolean isDefaultNamespace(String namespaceURI) {
return document.isDefaultNamespace(namespaceURI);
}
public String lookupNamespaceURI(String prefix) {
return document.lookupNamespaceURI(prefix);
}
public boolean isEqualNode(Node node) {
return document.isEqualNode(node);
}
public Object getFeature(String feature, String version) {
return document.getFeature(feature, version);
}
public Object setUserData(String key, Object data, UserDataHandler handler) {
return document.setUserData(key, data, handler);
}
public Object getUserData(String key) {
return document.getUserData(key);
}
public String getValue() {
//There are no immediate child text nodes to soap part
return null;
}
public void setParentElement(SOAPElement parent) throws SOAPException {
throw new SOAPException("Cannot set the parent element of SOAPPart");
}
public SOAPElement getParentElement() {
return null; //SOAP part is the root element
}
public void detachNode() {
//nothing to do here
}
public void recycleNode() {
//nothing to do here
}
public void setValue(String value) {
throw new IllegalStateException("Cannot set value of SOAPPart.");
}
}
Other Axis 2 examples (source code examples)Here is a short list of links related to this Axis 2 SOAPPartImpl.java source code file: |
The search page
Other Axis 2 source code examples at this package level
Click here to learn more about this project
