Modified: webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/SOAPPartImpl.java URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/SOAPPartImpl.java?rev=365487&r1=365486&r2=365487&view=diff ============================================================================== --- webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/SOAPPartImpl.java (original) +++ webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/SOAPPartImpl.java Mon Jan 2 16:28:43 2006 @@ -15,16 +15,32 @@ */ package org.apache.axis2.saaj; +import org.apache.axis2.soap.impl.dom.soap11.SOAP11Factory; import org.apache.axis2.soap.impl.llom.builder.StAXSOAPModelBuilder; import org.apache.axis2.transport.http.HTTPConstants; import org.apache.axis2.util.SessionUtils2; -import org.w3c.dom.*; +import org.w3c.dom.Attr; +import org.w3c.dom.CDATASection; +import org.w3c.dom.Comment; +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 javax.xml.soap.MimeHeaders; 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; @@ -32,67 +48,67 @@ public class SOAPPartImpl extends SOAPPart { - private SOAPMessageImpl msgObject; - private MimeHeaders mimeHeaders = new MimeHeaders(); - private Object envelope; - /** - * default message encoding charset - */ - private String currentEncoding = "UTF-8"; + private Document document; + private SOAPMessage soapMessage; + private SOAPEnvelopeImpl envelope; + private MimeHeadersEx mimeHeaders = new MimeHeadersEx(); - public SOAPPartImpl(SOAPMessageImpl parent, - Object initialContents, - boolean isBodyStream) throws SOAPException { - setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, - SessionUtils2.generateSessionId()); + public SOAPPartImpl(SOAPMessageImpl parentSoapMsg, + SOAPEnvelopeImpl soapEnvelope) { + + setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, SessionUtils2.generateSessionId()); setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml"); - StAXSOAPModelBuilder stAXSOAPModelBuilder; - msgObject = parent; + soapMessage = parentSoapMsg; + envelope = soapEnvelope; + this.document = soapEnvelope.getOwnerDocument(); + } + + public SOAPPartImpl(SOAPMessageImpl parentSoapMsg, + InputStream inputStream) throws SOAPException { + + setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, SessionUtils2.generateSessionId()); + setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml"); + + soapMessage = parentSoapMsg; + try { - if (initialContents instanceof SOAPEnvelope) { - ((SOAPEnvelopeImpl) initialContents).setOwnerDocument(this); - envelope = initialContents; - } else if (initialContents instanceof InputStream) { - //XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader((InputStream)initialContents); - InputStreamReader inr = new InputStreamReader( - (InputStream) initialContents); - stAXSOAPModelBuilder = - new StAXSOAPModelBuilder( - XMLInputFactory.newInstance() - .createXMLStreamReader(inr), null); - org.apache.axis2.soap.SOAPEnvelope omEnv = stAXSOAPModelBuilder.getSOAPEnvelope(); - envelope = new SOAPEnvelopeImpl(omEnv); - ((SOAPEnvelopeImpl) envelope).setOwnerDocument(this); - } + InputStreamReader isReader = new InputStreamReader(inputStream); - } catch (Exception e) { + StAXSOAPModelBuilder builder = + new StAXSOAPModelBuilder(XMLInputFactory.newInstance().createXMLStreamReader(isReader), + new SOAP11Factory(), + null); + org.apache.axis2.soap.SOAPEnvelope soapEnvelope = builder.getSOAPEnvelope(); + envelope = new SOAPEnvelopeImpl(soapEnvelope); + this.document = envelope.getOwnerDocument(); + } catch (XMLStreamException e) { + e.printStackTrace(); throw new SOAPException(e); } } - public SOAPMessageImpl getMessage() { - return msgObject; - } - /** - * Set the Message for this Part. - * Do not call this Directly. Called by Message. + * Obtain the SOAPMessage * - * @param msg the Message for this part + * @return the related SOAPMessage */ - public void setMessage(SOAPMessageImpl msg) { - this.msgObject = msg; + public SOAPMessage getSoapMessage() { + return soapMessage; } /** - * @see javax.xml.soap.SOAPPart#getEnvelope() + * Gets the SOAPEnvelope object associated with + * this SOAPPart object. Once the SOAP envelope is + * obtained, it can be used to get its contents. + * + * @return the SOAPEnvelope object for this + * SOAPPart object + * @throws SOAPException if there is a SOAP error */ public SOAPEnvelope getEnvelope() throws SOAPException { - //if(envelope != null) - return (SOAPEnvelope) envelope; - + return envelope; } /** @@ -148,9 +164,12 @@ * 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 MimeHeader 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 + * @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) { @@ -158,10 +177,22 @@ } /** - * Add the specified MIME header, as per JAXM. + * Creates a MimeHeader object with the specified + * name and value and adds it to this SOAPPart + * object. If a MimeHeader with the specified + * name already exists, this method adds the specified value + * to the already existing value(s). + *

+ *

Note that RFC822 headers can contain only US-ASCII + * characters.

* - * @param header the header to add - * @param value the value of that header + * @param header a String giving the + * header name + * @param value a String 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); @@ -180,397 +211,888 @@ } /** - * Get all headers that match. + * Retrieves all MimeHeader objects that match + * a name in the given array. * - * @param match an array of Strings giving mime header names - * @return an Iterator over all values matching these headers + * @param names a String 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 Iterator + * object */ - public java.util.Iterator getMatchingMimeHeaders(final String[] match) { - return mimeHeaders.getMatchingHeaders(match); + public Iterator getMatchingMimeHeaders(String[] names) { + return mimeHeaders.getMatchingHeaders(names); } /** - * Get all headers that do not match. + * Retrieves all MimeHeader objects whose name + * does not match a name in the given array. * - * @param match an array of Strings giving mime header names - * @return an Iterator over all values not matching these - * headers + * @param names a String array with + * the name(s) of the MIME headers not to be returned + * @return all of the MIME headers in this SOAPPart + * object except those that match one of the names in the + * given array. The nonmatching MIME headers are returned as + * an Iterator object. */ - public java.util.Iterator getNonMatchingMimeHeaders(final String[] match) { - return mimeHeaders.getNonMatchingHeaders(match); + public Iterator getNonMatchingMimeHeaders(String[] names) { + return mimeHeaders.getNonMatchingHeaders(names); } - /* (non-Javadoc) - * @see javax.xml.soap.SOAPPart#setContent(javax.xml.transform.Source) + /** + * Sets the content of the SOAPEnvelope object + * with the data from the given Source object. + * + * @param source javax.xml.transform.Source 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 { - // TODO Auto-generated method stub - + //TODO: implementation + throw new UnsupportedOperationException("TODO"); } - /* (non-Javadoc) - * @see javax.xml.soap.SOAPPart#getContent() - */ - public Source getContent() throws SOAPException { - // TODO Auto-generated method stub - return null; - } - - /** - * Implementation of org.w3c.Document - * Most of methods will be implemented using the delgate - * instance of SOAPDocumentImpl - * This is for two reasons: - * - possible change of message classes, by extenstion of xerces implementation - * - we cannot extends SOAPPart (multiple inheritance), - * since it is defined as Abstract class - * *********************************************************** - */ - - private Document document = new SOAPDocumentImpl(this); - /** - * @since SAAJ 1.2 + * Returns the content of the SOAPEnvelope as a JAXP + * Source object. + * + * @return the content as a + * javax.xml.transform.Source object + * @throws SOAPException if the implementation cannot + * convert the specified Source object + * @see #setContent(javax.xml.transform.Source) setContent(javax.xml.transform.Source) */ - public Document getSOAPDocument() { - if (document == null) { - document = new SOAPDocumentImpl(this); - } - return document; + public Source getContent() throws SOAPException { + //TODO: implementation + throw new UnsupportedOperationException("TODO"); } /** - * @return + * The Document Type Declaration (see DocumentType) + * associated with this document. For HTML documents as well as XML + * documents without a document type declaration this returns + * null. The DOM Level 2 does not support editing the + * Document Type Declaration. docType cannot be altered in + * any way, including through the use of methods inherited from the + * Node interface, such as insertNode or + * removeNode. */ public DocumentType getDoctype() { return document.getDoctype(); } /** - * @return + * The DOMImplementation object that handles this document. A + * DOM application may use objects from multiple implementations. */ public DOMImplementation getImplementation() { return document.getImplementation(); } /** - * SOAPEnvelope is the Document Elements of this XML document + * 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". */ - protected Document mDocument; - public Element getDocumentElement() { - try { - return getEnvelope(); - } catch (SOAPException se) { - return null; - } + return document.getDocumentElement(); } /** - * @param tagName - * @return - * @throws DOMException + * Creates an element of the type specified. Note that the instance + * returned implements the Element interface, so attributes + * can be specified directly on the returned object. + *
In addition, if there are known attributes with default values, + * Attr nodes representing them are automatically created + * and attached to the element. + *
To create an element with a qualified name and namespace URI, use + * the createElementNS method. + * + * @param tagName The name of the element type to instantiate. For XML, + * this is case-sensitive. For HTML, the tagName + * parameter may be provided in any case, but it must be mapped to the + * canonical uppercase form by the DOM implementation. + * @return A new Element object with the + * nodeName attribute set to tagName, and + * localName, prefix, and + * namespaceURI set to null. + * @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 DocumentFragment object. + * + * @return A new DocumentFragment. + */ public DocumentFragment createDocumentFragment() { return document.createDocumentFragment(); } + /** + * Creates a Text node given the specified string. + * + * @param data The data for the node. + * @return The new Text object. + */ public Text createTextNode(String data) { return document.createTextNode(data); } + /** + * Creates a CDATASection node whose value is the specified + * string. + * + * @param data The data for the CDATASection contents. + * @return The new CDATASection 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 CDATASection node whose value is the specified + * string. + * + * @param data The data for the CDATASection contents. + * @return The new CDATASection 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); } - public ProcessingInstruction createProcessingInstruction(String target, - String data) - throws DOMException { + /** + * Creates a ProcessingInstruction 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 ProcessingInstruction object. + * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified target contains an + * illegal character. + *
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 Attr of the given name. Note that the + * Attr instance can then be set on an Element + * using the setAttributeNode method. + *
To create an attribute with a qualified name and namespace URI, use + * the createAttributeNS method. + * + * @param name The name of the attribute. + * @return A new Attr object with the nodeName + * attribute set to name, and localName, + * prefix, and namespaceURI set to + * null. 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 EntityReference object. In addition, if the + * referenced entity is known, the child list of the + * EntityReference node is made the same as that of the + * corresponding Entity node.If any descendant of the + * Entity node has an unbound namespace prefix, the + * corresponding descendant of the created EntityReference + * node is also unbound; (its namespaceURI is + * null). 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 EntityReference object. + * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an + * illegal character. + *
NOT_SUPPORTED_ERR: Raised if this document is an HTML document. + */ public EntityReference createEntityReference(String name) throws DOMException { return document.createEntityReference(name); } + /** + * Returns a NodeList of all the Elements with a + * given tag name in the order in which they are encountered in a + * preorder traversal of the Document tree. + * + * @param tagname The name of the tag to match on. The special value "*" + * matches all tags. + * @return A new NodeList object containing all the matched + * Elements. + */ public NodeList getElementsByTagName(String tagname) { return document.getElementsByTagName(tagname); } - public Node importNode(Node importedNode, boolean deep) - throws DOMException { + /** + * Imports a node from another document to this document. The returned + * node has no parent; (parentNode is null). + * The source node is not altered or removed from the original document; + * this method creates a new copy of the source node. + *
For all nodes, importing a node creates a node object owned by the + * importing document, with attribute values identical to the source + * node's nodeName and nodeType, plus the + * attributes related to namespaces (prefix, + * localName, and namespaceURI). As in the + * cloneNode operation on a Node, the source + * node is not altered. + *
Additional information is copied as appropriate to the + * nodeType, 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. + *
+ *
ATTRIBUTE_NODE
+ *
The ownerElement attribute + * is set to null and the specified flag is + * set to true on the generated Attr. The + * descendants of the source Attr are recursively imported + * and the resulting nodes reassembled to form the corresponding subtree. + * Note that the deep parameter has no effect on + * Attr nodes; they always carry their children with them + * when imported.
+ *
DOCUMENT_FRAGMENT_NODE
+ *
If the deep option + * was set to 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 + * DocumentFragment.
+ *
DOCUMENT_NODE
+ *
Document + * nodes cannot be imported.
+ *
DOCUMENT_TYPE_NODE
+ *
DocumentType + * nodes cannot be imported.
+ *
ELEMENT_NODE
+ *
Specified attribute nodes of the + * source element are imported, and the generated Attr + * nodes are attached to the generated 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 importNode 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.
+ *
ENTITY_NODE
+ *
Entity nodes can be + * imported, however in the current release of the DOM the + * DocumentType is readonly. Ability to add these imported + * nodes to a DocumentType will be considered for addition + * to a future release of the DOM.On import, the publicId, + * systemId, and notationName attributes are + * copied. If a deep import is requested, the descendants + * of the the source Entity are recursively imported and + * the resulting nodes reassembled to form the corresponding subtree.
+ *
+ * ENTITY_REFERENCE_NODE
+ *
Only the EntityReference itself is + * copied, even if a 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.
+ *
NOTATION_NODE
+ *
+ * Notation nodes can be imported, however in the current + * release of the DOM the DocumentType is readonly. Ability + * to add these imported nodes to a DocumentType will be + * considered for addition to a future release of the DOM.On import, the + * publicId and systemId attributes are copied. + * Note that the deep parameter has no effect on + * Notation nodes since they never have any children.
+ *
+ * PROCESSING_INSTRUCTION_NODE
+ *
The imported node copies its + * target and data values from those of the + * source node.
+ *
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE
+ *
These three + * types of nodes inheriting from CharacterData copy their + * data and length attributes from those of + * the source node.
+ *
+ * + * @param importedNode The node to import. + * @param deep If true, recursively import the subtree under + * the specified node; if false, import only the node + * itself, as explained above. This has no effect on Attr + * , EntityReference, and Notation nodes. + * @return The imported node that belongs to this 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); } - public Element createElementNS(String namespaceURI, String qualifiedName) - throws DOMException { + /** + * 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 Element object with the following + * attributes: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
AttributeValue
Node.nodeName + * qualifiedName
Node.namespaceURI + * namespaceURI
Node.prefixprefix, extracted + * from qualifiedName, or null if there is + * no prefix
Node.localNamelocal name, extracted from + * qualifiedName
Element.tagName + * qualifiedName
+ * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name + * contains an illegal character, per the XML 1.0 specification . + *
NAMESPACE_ERR: Raised if the qualifiedName is + * malformed per the Namespaces in XML specification, if the + * qualifiedName has a prefix and the + * namespaceURI is null, or if the + * qualifiedName has a prefix that is "xml" and the + * namespaceURI is different from " + * http://www.w3.org/XML/1998/namespace" . + *
NOT_SUPPORTED_ERR: Always thrown if the current document does not + * support the "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); } - public Attr createAttributeNS(String namespaceURI, String qualifiedName) - throws DOMException { + /** + * 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 Attr object with the following attributes: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
+ * AttributeValue
Node.nodeNamequalifiedName
+ * Node.namespaceURInamespaceURI
+ * Node.prefixprefix, extracted from + * qualifiedName, or null if there is no + * prefix
Node.localNamelocal name, extracted from + * qualifiedName
Attr.name + * qualifiedName
Node.nodeValuethe empty + * string
+ * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name + * contains an illegal character, per the XML 1.0 specification . + *
NAMESPACE_ERR: Raised if the qualifiedName is + * malformed per the Namespaces in XML specification, if the + * qualifiedName has a prefix and the + * namespaceURI is null, if the + * qualifiedName has a prefix that is "xml" and the + * namespaceURI is different from " + * http://www.w3.org/XML/1998/namespace", or if the + * qualifiedName, or its prefix, is "xmlns" and the + * namespaceURI is different from " + * http://www.w3.org/2000/xmlns/". + *
NOT_SUPPORTED_ERR: Always thrown if the current document does not + * support the "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); } - public NodeList getElementsByTagNameNS(String namespaceURI, - String localName) { + /** + * Returns a 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 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 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 Element whose ID is given by + * elementId. If no such element exists, returns + * null. Behavior is not defined if more than one element + * has this 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 null. + * + * @param elementId The unique 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 null; - } - - public String getXmlEncoding() { - return null; - } - - public boolean getXmlStandalone() { - return false; - } - - public void setXmlStandalone(boolean xmlStandalone) throws DOMException { - - } - - public String getXmlVersion() { - return null; - } - - public void setXmlVersion(String xmlVersion) throws DOMException { - - } - - ///////////////////////////////////////////////////////////// - - public String getEncoding() { - return currentEncoding; - } - - public void setEncoding(String s) { - currentEncoding = s; - } - - public boolean getStandalone() { - throw new UnsupportedOperationException("Not yet implemented.71"); - } - - - public void setStandalone(boolean flag) { - throw new UnsupportedOperationException("Not yet implemented.72"); - } - - public boolean getStrictErrorChecking() { - throw new UnsupportedOperationException("Not yet implemented.73"); - } - - - public void setStrictErrorChecking(boolean flag) { - throw new UnsupportedOperationException("Not yet implemented. 74"); - } - - public String getDocumentURI() { - return null; - } - - public void setDocumentURI(String documentURI) { - - } - - - public String getVersion() { - throw new UnsupportedOperationException("Not yet implemented. 75"); - } - - - public void setVersion(String s) { - throw new UnsupportedOperationException("Not yet implemented.76"); - } - - - public Node adoptNode(Node node) - throws DOMException { - throw new UnsupportedOperationException("Not yet implemented.77"); - } - - public DOMConfiguration getDomConfig() { - return null; - } - - public void normalizeDocument() { - - } - - public Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException { - return null; - } - /** - * Node Implementation + * 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 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 DOMString variable on the implementation + * platform. + */ public String getNodeValue() throws DOMException { return document.getNodeValue(); } - public void setNodeValue(String nodeValue) throws DOMException { - document.setNodeValue(nodeValue); + /** + * The value of this node, depending on its type; see the table above. + * When it is defined to be 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 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 Attr, + * Document, 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 + * null. + */ public Node getParentNode() { return document.getParentNode(); } + /** + * A NodeList that contains all children of this node. If + * there are no children, this is a NodeList containing no + * nodes. + */ public NodeList getChildNodes() { return document.getChildNodes(); } + /** + * The first child of this node. If there is no such node, this returns + * null. + */ public Node getFirstChild() { return document.getFirstChild(); } + /** + * The last child of this node. If there is no such node, this returns + * null. + */ public Node getLastChild() { return document.getLastChild(); } + /** + * The node immediately preceding this node. If there is no such node, + * this returns null. + */ public Node getPreviousSibling() { return document.getPreviousSibling(); } + /** + * The node immediately following this node. If there is no such node, + * this returns null. + */ public Node getNextSibling() { return document.getNextSibling(); } + /** + * A NamedNodeMap containing the attributes of this node (if + * it is an Element) or null otherwise. + */ public NamedNodeMap getAttributes() { return document.getAttributes(); } + /** + * The Document object associated with this node. This is + * also the Document object used to create new nodes. When + * this node is a Document or a DocumentType + * which is not used with any Document yet, this is + * null. + */ public Document getOwnerDocument() { return document.getOwnerDocument(); } + /** + * Inserts the node newChild before the existing child node + * refChild. If refChild is null, + * insert newChild at the end of the list of children. + *
If newChild is a DocumentFragment object, + * all of its children are inserted, in the same order, before + * refChild. If the 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 newChild node, or if + * the node to insert is one of this node's ancestors or this node + * itself. + *
WRONG_DOCUMENT_ERR: Raised if newChild was created + * from a different document than the one that created this node. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or + * if the parent of the node being inserted is readonly. + *
NOT_FOUND_ERR: Raised if 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 oldChild with newChild + * in the list of children, and returns the oldChild node. + *
If newChild is a DocumentFragment object, + * oldChild is replaced by all of the + * DocumentFragment children, which are inserted in the + * same order. If the 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 newChild node, or if + * the node to put in is one of this node's ancestors or this node + * itself. + *
WRONG_DOCUMENT_ERR: Raised if newChild was created + * from a different document than the one that created this node. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of + * the new node is readonly. + *
NOT_FOUND_ERR: Raised if 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 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. + *
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 newChild to the end of the list of children + * of this node. If the newChild is already in the tree, it + * is first removed. + * + * @param newChild The node to add.If it is a + * 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 newChild node, or if + * the node to append is one of this node's ancestors or this node + * itself. + *
WRONG_DOCUMENT_ERR: Raised if newChild was created + * from a different document than the one that created this node. + *
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 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; ( + * parentNode is null.). + *
Cloning an 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 Text node. Cloning an Attribute + * directly, as opposed to be cloned as part of an Element + * cloning operation, returns a specified attribute ( + * specified is true). Cloning any other type + * of node simply returns a copy of this node. + *
Note that cloning an immutable subtree results in a mutable copy, + * but the children of an EntityReference clone are readonly + * . In addition, clones of unspecified Attr nodes are + * specified. And, cloning Document, + * DocumentType, Entity, and + * Notation nodes is implementation dependent. + * + * @param deep If true, recursively clone the subtree under + * the specified node; if false, clone only the node + * itself (and its attributes, if it is an Element). + * @return The duplicate node. + */ public Node cloneNode(boolean deep) { return document.cloneNode(deep); } + /** + * Puts all Text nodes in the full depth of the sub-tree + * underneath this Node, including attribute nodes, into a + * "normal" form where only structure (e.g., elements, comments, + * processing instructions, CDATA sections, and entity references) + * separates Text nodes, i.e., there are neither adjacent + * Text nodes nor empty 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 + * CDATASections, the normalize operation alone may not be + * sufficient, since XPointers do not differentiate between + * Text nodes and 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 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 true. + * @return Returns true if the specified feature is + * supported on this node, 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 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. + *
For nodes of any type other than ELEMENT_NODE and + * ATTRIBUTE_NODE and nodes created with a DOM Level 1 + * method, such as createElement from the + * Document interface, this is always 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 null if it is + * unspecified. + *
Note that setting this attribute, when permitted, changes the + * nodeName attribute, which holds the qualified name, as + * well as the tagName and name attributes of + * the Element and Attr interfaces, when + * applicable. + *
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 + * namespaceURI and localName do not change. + *
For nodes of any type other than ELEMENT_NODE and + * ATTRIBUTE_NODE and nodes created with a DOM Level 1 + * method, such as createElement from the + * Document interface, this is always null. + * + * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an + * illegal character, per the XML 1.0 specification . + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + *
NAMESPACE_ERR: Raised if the specified prefix is + * malformed per the Namespaces in XML specification, if the + * namespaceURI of this node is null, if the + * specified prefix is "xml" and the 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 namespaceURI of this node is different from " + * http://www.w3.org/2000/xmlns/", or if this node is an attribute and + * the qualifiedName of this node is "xmlns" . + * @since DOM Level 2 + */ public String getPrefix() { return document.getPrefix(); } - public void setPrefix(String prefix) throws DOMException { - document.setPrefix(prefix); + /** + * The namespace prefix of this node, or null if it is + * unspecified. + *
Note that setting this attribute, when permitted, changes the + * nodeName attribute, which holds the qualified name, as + * well as the tagName and name attributes of + * the Element and Attr interfaces, when + * applicable. + *
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 + * namespaceURI and localName do not change. + *
For nodes of any type other than ELEMENT_NODE and + * ATTRIBUTE_NODE and nodes created with a DOM Level 1 + * method, such as createElement from the + * Document interface, this is always null. + * + * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an + * illegal character, per the XML 1.0 specification . + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + *
NAMESPACE_ERR: Raised if the specified prefix is + * malformed per the Namespaces in XML specification, if the + * namespaceURI of this node is null, if the + * specified prefix is "xml" and the 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 namespaceURI of this node is different from " + * http://www.w3.org/2000/xmlns/", or if this node is an attribute and + * the 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. + *
For nodes of any type other than ELEMENT_NODE and + * ATTRIBUTE_NODE and nodes created with a DOM Level 1 + * method, such as createElement from the + * Document interface, this is always null. + * + * @since DOM Level 2 + */ public String getLocalName() { return document.getLocalName(); } + /** + * Returns whether this node (if it is an element) has any attributes. + * + * @return true if this node has any attributes, + * false otherwise. + * @since DOM Level 2 + */ public boolean hasAttributes() { return document.hasAttributes(); } - public String getBaseURI() { - return null; - } - - public short compareDocumentPosition(Node other) throws DOMException { - return 0; + protected void setMessage(SOAPMessageImpl message) { + soapMessage = message; } - - public String getTextContent() throws DOMException { - return null; - } - - public void setTextContent(String textContent) throws DOMException { - - } - - public boolean isSameNode(Node other) { - return false; - } - - public String lookupPrefix(String namespaceURI) { - return null; - } - - public boolean isDefaultNamespace(String namespaceURI) { - return false; - } - - public String lookupNamespaceURI(String prefix) { - return null; - } - - public boolean isEqualNode(Node arg) { - return false; - } - - public Object getFeature(String feature, String version) { - return null; - } - - public Object setUserData(String key, Object data, UserDataHandler handler) { - return null; - } - - public Object getUserData(String key) { - return null; - } - } Added: webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/TextImplEx.java URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/TextImplEx.java?rev=365487&view=auto ============================================================================== --- webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/TextImplEx.java (added) +++ webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/saaj/TextImplEx.java Mon Jan 2 16:28:43 2006 @@ -0,0 +1,277 @@ +/* + * 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.axis2.om.DOOMAbstractFactory; +import org.apache.axis2.om.OMContainer; +import org.apache.axis2.om.OMException; +import org.apache.axis2.om.impl.OMOutputImpl; +import org.apache.axis2.om.impl.dom.TextImpl; +import org.w3c.dom.DOMException; + +import javax.xml.soap.Text; +import javax.xml.stream.XMLStreamException; + +public class TextImplEx extends NodeImplEx implements Text { + + //TODO: assign textNode + + private TextImpl textNode; + + public TextImplEx(String data) { + textNode = (TextImpl) DOOMAbstractFactory.getOMFactory().createText(data); + } + /*public TextImplEx(SOAPElementImpl parent, String s) throws SOAPException { + //super(); + //super.setParentElement(parent); + OMElement par = parent.getOMElement(); + omNode = + omText = + org.apache.axis2.om.OMAbstractFactory.getOMFactory() + .createText(par, s); + } + + public TextImplEx(org.w3c.dom.CharacterData data) { + if (data == null) { + throw new IllegalArgumentException("Text value may not be null."); + } + omText = + org.apache.axis2.om.OMAbstractFactory.getOMFactory() + .createText(data.getData()); + } + + public TextImplEx(OMText omText) { + omNode = this.omText = omText; + }*/ + + /** + * Retrieves whether this Text object + * represents a comment. + * + * @return true if this Text object is + * a comment; false otherwise + */ + public boolean isComment() { + String value = textNode.getText(); + return value.startsWith(""); + } + + /** + * The name of this node, depending on its type; see the table above. + */ + public String getNodeName() { + return textNode.getNodeName(); + } + + /** + * A code representing the type of the underlying object, as defined above. + */ + public short getNodeType() { + return textNode.getNodeType(); + } + + /** + * Breaks this node into two nodes at the specified offset, + * keeping both in the tree as siblings. After being split, this node + * will contain all the content up to the offset point. A + * new node of the same type, which contains all the content at and + * after the offset point, is returned. If the original + * node had a parent node, the new node is inserted as the next sibling + * of the original node. When the offset is equal to the + * length of this node, the new node has no data. + * + * @param offset The 16-bit unit offset at which to split, starting from + * 0. + * @return The new node, of the same type as this node. + * @throws DOMException INDEX_SIZE_ERR: Raised if the specified offset is negative or greater + * than the number of 16-bit units in data. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + */ + public org.w3c.dom.Text splitText(int offset) throws DOMException { + return textNode.splitText(offset); + } + + /** + * The character data of the node that implements this interface. The DOM + * implementation may not put arbitrary limits on the amount of data + * that may be stored in a CharacterData node. However, + * implementation limits may mean that the entirety of a node's data may + * not fit into a single DOMString. In such cases, the user + * may call substringData to retrieve the data in + * appropriately sized pieces. + * + * @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 DOMString variable on the implementation + * platform. + */ + public String getData() throws DOMException { + return textNode.getData(); + } + + /** + * The character data of the node that implements this interface. The DOM + * implementation may not put arbitrary limits on the amount of data + * that may be stored in a CharacterData node. However, + * implementation limits may mean that the entirety of a node's data may + * not fit into a single DOMString. In such cases, the user + * may call substringData to retrieve the data in + * appropriately sized pieces. + * + * @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 DOMString variable on the implementation + * platform. + */ + public void setData(String data) throws DOMException { + textNode.setData(data); + } + + /** + * Extracts a range of data from the node. + * + * @param offset Start offset of substring to extract. + * @param count The number of 16-bit units to extract. + * @return The specified substring. If the sum of offset and + * count exceeds the length, then all 16-bit + * units to the end of the data are returned. + * @throws DOMException INDEX_SIZE_ERR: Raised if the specified offset is + * negative or greater than the number of 16-bit units in + * data, or if the specified count is + * negative. + *
DOMSTRING_SIZE_ERR: Raised if the specified range of text does + * not fit into a DOMString. + */ + public String substringData(int offset, int count) throws DOMException { + return textNode.substringData(offset, count); + } + + /** + * Append the string to the end of the character data of the node. Upon + * success, data provides access to the concatenation of + * data and the DOMString specified. + * + * @param value The DOMString to append. + * @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + */ + public void appendData(String value) throws DOMException { + textNode.appendData(value); + } + + /** + * Insert a string at the specified 16-bit unit offset. + * + * @param offset The character offset at which to insert. + * @param data The DOMString to insert. + * @throws DOMException INDEX_SIZE_ERR: Raised if the specified offset is + * negative or greater than the number of 16-bit units in + * data. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + */ + public void insertData(int offset, String data) throws DOMException { + textNode.insertData(offset, data); + } + + /** + * Remove a range of 16-bit units from the node. Upon success, + * data and length reflect the change. + * + * @param offset The offset from which to start removing. + * @param count The number of 16-bit units to delete. If the sum of + * offset and count exceeds + * length then all 16-bit units from offset + * to the end of the data are deleted. + * @throws DOMException INDEX_SIZE_ERR: Raised if the specified offset is + * negative or greater than the number of 16-bit units in + * data, or if the specified count is + * negative. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + */ + public void deleteData(int offset, int count) throws DOMException { + textNode.deleteData(offset, count); + } + + /** + * Replace the characters starting at the specified 16-bit unit offset + * with the specified string. + * + * @param offset The offset from which to start replacing. + * @param count The number of 16-bit units to replace. If the sum of + * offset and count exceeds + * length, then all 16-bit units to the end of the data + * are replaced; (i.e., the effect is the same as a remove + * method call with the same range, followed by an append + * method invocation). + * @param data The DOMString with which the range must be + * replaced. + * @throws DOMException INDEX_SIZE_ERR: Raised if the specified offset is + * negative or greater than the number of 16-bit units in + * data, or if the specified count is + * negative. + *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. + */ + public void replaceData(int offset, int count, String data) throws DOMException { + textNode.replaceData(offset, count, data); + } + + /* (non-Javadoc) + * @see org.apache.axis2.om.impl.OMNodeEx#setParent(org.apache.axis2.om.OMContainer) + */ + public void setParent(OMContainer element) { + textNode.setParent(element); + } + + /* (non-Javadoc) + * @see org.apache.axis2.om.OMNode#getParent() + */ + public OMContainer getParent() { + return textNode.getParent(); + } + + /* (non-Javadoc) + * @see org.apache.axis2.om.OMNode#discard() + */ + public void discard() throws OMException { + textNode.discard(); + } + + /* (non-Javadoc) + * @see org.apache.axis2.om.OMNode#serialize(org.apache.axis2.om.impl.OMOutputImpl) + */ + public void serialize(OMOutputImpl omOutput) throws XMLStreamException { + textNode.serialize(omOutput); + } + + /* (non-Javadoc) + * @see org.apache.axis2.om.OMNode#serializeAndConsume(org.apache.axis2.om.impl.OMOutputImpl) + */ + public void serializeAndConsume(OMOutputImpl omOutput) throws XMLStreamException { + textNode.serializeAndConsume(omOutput); + } + + /** + * Retrieve the text value (data) of this + * + * @return The text value (data) of this + */ + public String getValue() { + return textNode.getData(); + } + + public String toString() { + return getValue(); + } +} Added: webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/util/SAAJUtil.java URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/util/SAAJUtil.java?rev=365487&view=auto ============================================================================== --- webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/util/SAAJUtil.java (added) +++ webservices/axis2/trunk/java/modules/saaj/src/org/apache/axis2/util/SAAJUtil.java Mon Jan 2 16:28:43 2006 @@ -0,0 +1,149 @@ +/* + * 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.util; + +import org.apache.axis2.om.DOOMAbstractFactory; +import org.apache.axis2.om.OMElement; +import org.apache.axis2.om.impl.dom.DocumentImpl; +import org.apache.axis2.om.impl.llom.builder.StAXOMBuilder; +import org.apache.axis2.soap.SOAP11Constants; +import org.apache.axis2.soap.SOAP12Constants; +import org.apache.axis2.soap.SOAPEnvelope; +import org.apache.axis2.soap.SOAPFactory; +import org.apache.axis2.soap.impl.llom.builder.StAXSOAPModelBuilder; +import org.apache.xml.security.utils.XMLUtils; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; + +/** + * Utility class for the Axis2-WSS4J Module + */ +public class SAAJUtil { + + /** + * Create a DOM Document using the org.apache.axis2.soap.SOAPEnvelope + * + * @param env An org.apache.axis2.soap.SOAPEnvelope instance + * @return the DOM Document of the given SOAP Envelope + */ + public static Document getDocumentFromSOAPEnvelope(org.apache.axis2.soap.SOAPEnvelope env) { + env.build(); + + //Check the namespace and find SOAP version and factory + String nsURI; + SOAPFactory factory; + if (env.getNamespace().getName().equals(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI)) { + nsURI = SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI; + factory = DOOMAbstractFactory.getSOAP11Factory(); + } else { + nsURI = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI; + factory = DOOMAbstractFactory.getSOAP11Factory(); + } + + StAXSOAPModelBuilder stAXSOAPModelBuilder = new StAXSOAPModelBuilder(env.getXMLStreamReader(), factory, nsURI); + SOAPEnvelope envelope = (stAXSOAPModelBuilder).getSOAPEnvelope(); + envelope.build(); + + Element envElem = (Element) envelope; + return envElem.getOwnerDocument(); + } + + /** + * Create a DOM Document using the org.apache.axis2.soap.SOAPEnvelope + * + * @param env An org.apache.axis2.soap.SOAPEnvelope instance + * @return the org.apache.axis2.soap.impl.dom.SOAPEnvelopeImpl of the given SOAP Envelope + */ + public static org.apache.axis2.soap.impl.dom.SOAPEnvelopeImpl + toDOOMSOAPEnvelope(org.apache.axis2.soap.SOAPEnvelope env) { + env.build(); + + //Check the namespace and find SOAP version and factory + String nsURI; + SOAPFactory factory; + if (env.getNamespace().getName().equals(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI)) { + nsURI = SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI; + factory = DOOMAbstractFactory.getSOAP11Factory(); + } else { + nsURI = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI; + factory = DOOMAbstractFactory.getSOAP11Factory(); + } + + StAXSOAPModelBuilder stAXSOAPModelBuilder = + new StAXSOAPModelBuilder(env.getXMLStreamReader(), factory, nsURI); + SOAPEnvelope envelope = (stAXSOAPModelBuilder).getSOAPEnvelope(); + envelope.build(); + + return (org.apache.axis2.soap.impl.dom.SOAPEnvelopeImpl) envelope; + } + + public static SOAPEnvelope getSOAPEnvelopeFromDOOMDocument(DocumentImpl doc) { + OMElement docElem = (OMElement) doc.getDocumentElement(); + StAXSOAPModelBuilder stAXSOAPModelBuilder = new StAXSOAPModelBuilder(docElem.getXMLStreamReader(), null); + return stAXSOAPModelBuilder.getSOAPEnvelope(); + } + + public static SOAPEnvelope toOMSOAPEnvelope(Element elem) { + OMElement docElem = (OMElement) elem; + StAXSOAPModelBuilder stAXSOAPModelBuilder = + new StAXSOAPModelBuilder(docElem.getXMLStreamReader(), null); + return stAXSOAPModelBuilder.getSOAPEnvelope(); + } + + /** + * Convert a given DOM Element to an OMElement + * + * @param element + * @return + */ + public static OMElement toOM(Element element) throws XMLStreamException { + ByteArrayOutputStream os = new ByteArrayOutputStream(); + XMLUtils.outputDOM(element, os, true); + + ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray()); + XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(is); + + StAXOMBuilder builder = new StAXOMBuilder(reader); + builder.setCache(true); + + return builder.getDocumentElement(); + } + + /** + * Convert a given OMElement to a DOM Element + * + * @param element + * @return + */ + public static Element toDOM(OMElement element) throws Exception { + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + element.serialize(baos); + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + factory.setNamespaceAware(true); + return factory.newDocumentBuilder().parse(bais).getDocumentElement(); + } +} Modified: webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentSerializationTest.java URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentSerializationTest.java?rev=365487&r1=365486&r2=365487&view=diff ============================================================================== --- webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentSerializationTest.java (original) +++ webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentSerializationTest.java Mon Jan 2 16:28:43 2006 @@ -10,6 +10,11 @@ import java.io.File; import java.io.InputStream; import java.io.OutputStream; +import java.io.FileInputStream; +import java.util.Iterator; + +import org.w3c.dom.Document; +import org.apache.axis2.om.impl.dom.DocumentImpl; public class AttachmentSerializationTest extends TestCase { @@ -28,7 +33,9 @@ int count = saveMsgWithAttachments(bais); assertEquals(count, 2); } catch (Exception e) { - throw new Exception("Fault returned from test: " + e); +// throw new Exception("Fault returned from test: " + e); + e.printStackTrace(); + fail("Unexpected Exception : " + e); } } @@ -41,12 +48,13 @@ MessageFactory mf = MessageFactory.newInstance(); SOAPMessage msg = mf.createMessage(); - SOAPPart sp = msg.getSOAPPart(); - SOAPEnvelope envelope = sp.getEnvelope(); + SOAPPart soapPart = msg.getSOAPPart(); + SOAPEnvelope envelope = soapPart.getEnvelope(); SOAPHeader header = envelope.getHeader(); SOAPBody body = envelope.getBody(); SOAPElement el = header.addHeaderElement(envelope.createName("field4", NS_PREFIX, NS_URI)); + SOAPElement el2 = el.addChildElement("field4b", NS_PREFIX); SOAPElement el3 = el2.addTextNode("field4value"); @@ -57,10 +65,13 @@ el2.addTextNode("bodyvalue3b"); el2 = el.addChildElement("datefield", NS_PREFIX); + // First Attachment AttachmentPart ap = msg.createAttachmentPart(); - ap.setContent("some attachment text...", "text/plain"); + final String testText = "some attachment text..."; + ap.setContent(testText, "text/plain"); msg.addAttachmentPart(ap); + // Second attachment String jpgfilename = "./test-resources/axis.jpg"; File myfile = new File(jpgfilename); FileDataSource fds = new FileDataSource(myfile); @@ -71,9 +82,23 @@ MimeHeaders headers = msg.getMimeHeaders(); assertTrue(headers != null); - String [] contentType = headers.getHeader("Content-Type"); + String [] contentType = headers.getHeader("Content-Type"); assertTrue(contentType != null); - + + for (Iterator iter = msg.getAttachments(); iter.hasNext();) { + AttachmentPart attachmentPart = (AttachmentPart) iter.next(); + final Object content = attachmentPart.getDataHandler().getContent(); + if(content instanceof String){ + assertEquals(testText, (String) content); + } else if(content instanceof FileInputStream){ + final FileInputStream fis = (FileInputStream) content; + /*File file = new File("output-file.jpg"); + file.createNewFile(); + + fis.read(new byte[(int)file.length()])*/ + } + } + msg.writeTo(os); os.flush(); msg.writeTo(System.out); Modified: webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentTest.java URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentTest.java?rev=365487&r1=365486&r2=365487&view=diff ============================================================================== --- webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentTest.java (original) +++ webservices/axis2/trunk/java/modules/saaj/test/org/apache/axis2/saaj/AttachmentTest.java Mon Jan 2 16:28:43 2006 @@ -19,46 +19,46 @@ public AttachmentTest(String name) { super(name); } - + public void testStringAttachment() throws Exception { - SOAPConnectionFactory scFactory = SOAPConnectionFactory.newInstance(); - SOAPConnection con = scFactory.createConnection(); - - MessageFactory factory = MessageFactory.newInstance(); - SOAPMessage message = factory.createMessage(); - AttachmentPart attachment = message.createAttachmentPart(); - String stringContent = "Update address for Sunny Skies " + - "Inc., to 10 Upbeat Street, Pleasant Grove, CA 95439"; - - attachment.setContent(stringContent, "text/plain"); - attachment.setContentId("update_address"); - message.addAttachmentPart(attachment); - - assertTrue(message.countAttachments() == 1); - - java.util.Iterator it = message.getAttachments(); - while (it.hasNext()) { - attachment = (AttachmentPart) it.next(); - Object content = attachment.getContent(); - String id = attachment.getContentId(); - System.out.println("Attachment " + id + " contains: " + content); - assertEquals(content, stringContent); - } - System.out.println("Here is what the XML message looks like:"); - message.writeTo(System.out); - - message.removeAllAttachments(); - assertTrue(message.countAttachments() == 0); + SOAPConnectionFactory scFactory = SOAPConnectionFactory.newInstance(); + SOAPConnection con = scFactory.createConnection(); + + MessageFactory factory = MessageFactory.newInstance(); + SOAPMessage message = factory.createMessage(); + AttachmentPart attachment = message.createAttachmentPart(); + String stringContent = "Update address for Sunny Skies " + + "Inc., to 10 Upbeat Street, Pleasant Grove, CA 95439"; + + attachment.setContent(stringContent, "text/plain"); + attachment.setContentId("update_address"); + message.addAttachmentPart(attachment); + + assertTrue(message.countAttachments()==1); + + java.util.Iterator it = message.getAttachments(); + while (it.hasNext()) { + attachment = (AttachmentPart) it.next(); + Object content = attachment.getContent(); + String id = attachment.getContentId(); + System.out.println("Attachment " + id + " contains: " + content); + assertEquals(content,stringContent); + } + System.out.println("Here is what the XML message looks like:"); + message.writeTo(System.out); + + message.removeAllAttachments(); + assertTrue(message.countAttachments()==0); } - + public void testMultipleAttachments() throws Exception { SOAPConnectionFactory scFactory = SOAPConnectionFactory.newInstance(); SOAPConnection con = scFactory.createConnection(); MessageFactory factory = MessageFactory.newInstance(); SOAPMessage msg = factory.createMessage(); - java.net.URL url1 = new java.net.URL("http://www.apache.org/licenses/LICENSE-2.0.html"); - java.net.URL url2 = new java.net.URL("http://www.apache.org/licenses/LICENSE-2.0.txt"); + java.net.URL url1 = new java.net.URL("http://slashdot.org/slashdot.xml"); + java.net.URL url2 = new java.net.URL("http://www.apache.org/LICENSE.txt"); AttachmentPart a1 = msg.createAttachmentPart(new javax.activation.DataHandler(url1)); a1.setContentType("text/xml"); @@ -70,58 +70,54 @@ a3.setContentType("text/plain"); msg.addAttachmentPart(a3); - assertTrue(msg.countAttachments() == 3); + assertTrue(msg.countAttachments()==3); javax.xml.soap.MimeHeaders mimeHeaders = new javax.xml.soap.MimeHeaders(); mimeHeaders.addHeader("Content-Type", "text/xml"); int nAttachments = 0; java.util.Iterator iterator = msg.getAttachments(mimeHeaders); - while (iterator.hasNext()) { + while (iterator.hasNext()) { nAttachments++; - AttachmentPart ap = (AttachmentPart) iterator.next(); - assertTrue(ap.equals(a1) || ap.equals(a2)); - } - assertTrue(nAttachments == 2); + AttachmentPart ap = (AttachmentPart)iterator.next(); + assertTrue(ap.equals(a1) || ap.equals(a2)); + } + assertTrue(nAttachments==2); } - + public void testBadAttSize() throws Exception { MessageFactory factory = MessageFactory.newInstance(); SOAPMessage message = factory.createMessage(); - ByteArrayInputStream ins = new ByteArrayInputStream(new byte[5]); - DataHandler dh = new DataHandler(new Src(ins, "text/plain")); + ByteArrayInputStream ins=new ByteArrayInputStream(new byte[5]); + DataHandler dh=new DataHandler(new Src(ins,"text/plain")); AttachmentPart part = message.createAttachmentPart(dh); - assertEquals("Size should match", 5, part.getSize()); + assertEquals("Size should match",5,part.getSize()); } - class Src implements DataSource { + class Src implements DataSource{ InputStream m_src; String m_type; - public Src(InputStream data, String type) { - m_src = data; - m_type = type; + public Src(InputStream data, String type){ + m_src=data; + m_type=type; } - - public String getContentType() { + public String getContentType(){ return m_type; } - - public InputStream getInputStream() throws IOException { + public InputStream getInputStream() throws IOException{ m_src.reset(); return m_src; } - - public String getName() { + public String getName(){ return "Some-Data"; } - - public OutputStream getOutputStream() { + public OutputStream getOutputStream(){ throw new UnsupportedOperationException("I don't give output streams"); } } - + public static void main(String[] args) throws Exception { AttachmentTest tester = new AttachmentTest("TestSAAJ"); tester.testMultipleAttachments();