ws-axis-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r365487 [4/5] - in /webservices/axis2/trunk/java/modules/saaj: ./ src/org/apache/axis2/saaj/ src/org/apache/axis2/util/ test/org/apache/axis2/saaj/
Date Tue, 03 Jan 2006 00:29:01 GMT
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 <code>Message</code> 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 <CODE>SOAPEnvelope</CODE> object associated with
+     * this <CODE>SOAPPart</CODE> object. Once the SOAP envelope is
+     * obtained, it can be used to get its contents.
+     *
+     * @return the <CODE>SOAPEnvelope</CODE> object for this <CODE>
+     *         SOAPPart</CODE> object
+     * @throws SOAPException if there is a SOAP error
      */
     public SOAPEnvelope getEnvelope() throws SOAPException {
-        //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 <CODE>MimeHeader</CODE> object.
-     * @ throws java.lang.IllegalArgumentException if
-     * there was a problem with the specified mime header name
-     * or value
+     * @throws java.lang.IllegalArgumentException
+     *          if
+     *          there was a problem with the specified mime header name
+     *          or value
+     * @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 <CODE>MimeHeader</CODE> object with the specified
+     * name and value and adds it to this <CODE>SOAPPart</CODE>
+     * object. If a <CODE>MimeHeader</CODE> with the specified
+     * name already exists, this method adds the specified value
+     * to the already existing value(s).
+     * <p/>
+     * <P>Note that RFC822 headers can contain only US-ASCII
+     * characters.</P>
      *
-     * @param header the header to add
-     * @param value  the value of that header
+     * @param header a <CODE>String</CODE> giving the
+     *               header name
+     * @param value  a <CODE>String</CODE> giving the
+     *               value to be set or added
+     * @throws IllegalArgumentException if
+     *                                  there was a problem with the specified mime header name
+     *                                  or value
      */
     public void addMimeHeader(String header, String value) {
         mimeHeaders.addHeader(header, value);
@@ -180,397 +211,888 @@
     }
 
     /**
-     * Get all headers that match.
+     * Retrieves all <CODE>MimeHeader</CODE> objects that match
+     * a name in the given array.
      *
-     * @param match an array of <code>String</code>s giving mime header names
-     * @return an <code>Iterator</code> over all values matching these headers
+     * @param names a <CODE>String</CODE> array with
+     *              the name(s) of the MIME headers to be returned
+     * @return all of the MIME headers that match one of the names
+     *         in the given array, returned as an <CODE>Iterator</CODE>
+     *         object
      */
-    public 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 <CODE>MimeHeader</CODE> objects whose name
+     * does not match a name in the given array.
      *
-     * @param match an array of <code>String</code>s giving mime header names
-     * @return an <code>Iterator</code> over all values not matching these
-     *         headers
+     * @param names a <CODE>String</CODE> array with
+     *              the name(s) of the MIME headers not to be returned
+     * @return all of the MIME headers in this <CODE>SOAPPart</CODE>
+     *         object except those that match one of the names in the
+     *         given array. The nonmatching MIME headers are returned as
+     *         an <CODE>Iterator</CODE> object.
      */
-    public 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 <CODE>SOAPEnvelope</CODE> object
+     * with the data from the given <CODE>Source</CODE> object.
+     *
+     * @param source javax.xml.transform.Source</CODE> object with the data to
+     *               be set
+     * @throws SOAPException if there is a problem in
+     *                       setting the source
+     * @see #getContent() getContent()
      */
     public void setContent(Source source) throws SOAPException {
-        // 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 <CODE>
+     * Source</CODE> object.
+     *
+     * @return the content as a <CODE>
+     *         javax.xml.transform.Source</CODE> object
+     * @throws SOAPException if the implementation cannot
+     *                       convert the specified <CODE>Source</CODE> object
+     * @see #setContent(javax.xml.transform.Source) setContent(javax.xml.transform.Source)
      */
-    public 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 <code>DocumentType</code>)
+     * associated with this document. For HTML documents as well as XML
+     * documents without a document type declaration this returns
+     * <code>null</code>. The DOM Level 2 does not support editing the
+     * Document Type Declaration. <code>docType</code> cannot be altered in
+     * any way, including through the use of methods inherited from the
+     * <code>Node</code> interface, such as <code>insertNode</code> or
+     * <code>removeNode</code>.
      */
     public DocumentType getDoctype() {
         return document.getDoctype();
     }
 
     /**
-     * @return
+     * The <code>DOMImplementation</code> 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 <code>Element</code> interface, so attributes
+     * can be specified directly on the returned object.
+     * <br>In addition, if there are known attributes with default values,
+     * <code>Attr</code> nodes representing them are automatically created
+     * and attached to the element.
+     * <br>To create an element with a qualified name and namespace URI, use
+     * the <code>createElementNS</code> method.
+     *
+     * @param tagName The name of the element type to instantiate. For XML,
+     *                this is case-sensitive. For HTML, the <code>tagName</code>
+     *                parameter may be provided in any case, but it must be mapped to the
+     *                canonical uppercase form by the DOM implementation.
+     * @return A new <code>Element</code> object with the
+     *         <code>nodeName</code> attribute set to <code>tagName</code>, and
+     *         <code>localName</code>, <code>prefix</code>, and
+     *         <code>namespaceURI</code> set to <code>null</code>.
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
+     *                      illegal character.
      */
     public Element createElement(String tagName) throws DOMException {
         return document.createElement(tagName);
     }
 
+    /**
+     * Creates an empty <code>DocumentFragment</code> object.
+     *
+     * @return A new <code>DocumentFragment</code>.
+     */
     public DocumentFragment createDocumentFragment() {
         return document.createDocumentFragment();
     }
 
+    /**
+     * Creates a <code>Text</code> node given the specified string.
+     *
+     * @param data The data for the node.
+     * @return The new <code>Text</code> object.
+     */
     public Text createTextNode(String data) {
         return document.createTextNode(data);
     }
 
+    /**
+     * Creates a <code>CDATASection</code> node whose value is the specified
+     * string.
+     *
+     * @param data The data for the <code>CDATASection</code> contents.
+     * @return The new <code>CDATASection</code> object.
+     * @throws DOMException NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
+     */
     public Comment createComment(String data) {
         return document.createComment(data);
     }
 
+    /**
+     * Creates a <code>CDATASection</code> node whose value is the specified
+     * string.
+     *
+     * @param data The data for the <code>CDATASection</code> contents.
+     * @return The new <code>CDATASection</code> object.
+     * @throws DOMException NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
+     */
     public CDATASection createCDATASection(String data) throws DOMException {
         return document.createCDATASection(data);
     }
 
-    public ProcessingInstruction createProcessingInstruction(String target,
-                                                             String data)
-            throws DOMException {
+    /**
+     * Creates a <code>ProcessingInstruction</code> node given the specified
+     * name and data strings.
+     *
+     * @param target The target part of the processing instruction.
+     * @param data   The data for the node.
+     * @return The new <code>ProcessingInstruction</code> object.
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified target contains an
+     *                      illegal character.
+     *                      <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
+     */
+    public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException {
         return document.createProcessingInstruction(target, data);
     }
 
+    /**
+     * Creates an <code>Attr</code> of the given name. Note that the
+     * <code>Attr</code> instance can then be set on an <code>Element</code>
+     * using the <code>setAttributeNode</code> method.
+     * <br>To create an attribute with a qualified name and namespace URI, use
+     * the <code>createAttributeNS</code> method.
+     *
+     * @param name The name of the attribute.
+     * @return A new <code>Attr</code> object with the <code>nodeName</code>
+     *         attribute set to <code>name</code>, and <code>localName</code>,
+     *         <code>prefix</code>, and <code>namespaceURI</code> set to
+     *         <code>null</code>. The value of the attribute is the empty string.
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
+     *                      illegal character.
+     */
     public Attr createAttribute(String name) throws DOMException {
         return document.createAttribute(name);
     }
 
+    /**
+     * Creates an <code>EntityReference</code> object. In addition, if the
+     * referenced entity is known, the child list of the
+     * <code>EntityReference</code> node is made the same as that of the
+     * corresponding <code>Entity</code> node.If any descendant of the
+     * <code>Entity</code> node has an unbound namespace prefix, the
+     * corresponding descendant of the created <code>EntityReference</code>
+     * node is also unbound; (its <code>namespaceURI</code> is
+     * <code>null</code>). The DOM Level 2 does not support any mechanism to
+     * resolve namespace prefixes.
+     *
+     * @param name The name of the entity to reference.
+     * @return The new <code>EntityReference</code> object.
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified name contains an
+     *                      illegal character.
+     *                      <br>NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
+     */
     public EntityReference createEntityReference(String name) throws DOMException {
         return document.createEntityReference(name);
     }
 
+    /**
+     * Returns a <code>NodeList</code> of all the <code>Elements</code> with a
+     * given tag name in the order in which they are encountered in a
+     * preorder traversal of the <code>Document</code> tree.
+     *
+     * @param tagname The name of the tag to match on. The special value "*"
+     *                matches all tags.
+     * @return A new <code>NodeList</code> object containing all the matched
+     *         <code>Elements</code>.
+     */
     public NodeList getElementsByTagName(String tagname) {
         return document.getElementsByTagName(tagname);
     }
 
-    public Node importNode(Node importedNode, boolean deep)
-            throws DOMException {
+    /**
+     * Imports a node from another document to this document. The returned
+     * node has no parent; (<code>parentNode</code> is <code>null</code>).
+     * The source node is not altered or removed from the original document;
+     * this method creates a new copy of the source node.
+     * <br>For all nodes, importing a node creates a node object owned by the
+     * importing document, with attribute values identical to the source
+     * node's <code>nodeName</code> and <code>nodeType</code>, plus the
+     * attributes related to namespaces (<code>prefix</code>,
+     * <code>localName</code>, and <code>namespaceURI</code>). As in the
+     * <code>cloneNode</code> operation on a <code>Node</code>, the source
+     * node is not altered.
+     * <br>Additional information is copied as appropriate to the
+     * <code>nodeType</code>, attempting to mirror the behavior expected if
+     * a fragment of XML or HTML source was copied from one document to
+     * another, recognizing that the two documents may have different DTDs
+     * in the XML case. The following list describes the specifics for each
+     * type of node.
+     * <dl>
+     * <dt>ATTRIBUTE_NODE</dt>
+     * <dd>The <code>ownerElement</code> attribute
+     * is set to <code>null</code> and the <code>specified</code> flag is
+     * set to <code>true</code> on the generated <code>Attr</code>. The
+     * descendants of the source <code>Attr</code> are recursively imported
+     * and the resulting nodes reassembled to form the corresponding subtree.
+     * Note that the <code>deep</code> parameter has no effect on
+     * <code>Attr</code> nodes; they always carry their children with them
+     * when imported.</dd>
+     * <dt>DOCUMENT_FRAGMENT_NODE</dt>
+     * <dd>If the <code>deep</code> option
+     * was set to <code>true</code>, the descendants of the source element
+     * are recursively imported and the resulting nodes reassembled to form
+     * the corresponding subtree. Otherwise, this simply generates an empty
+     * <code>DocumentFragment</code>.</dd>
+     * <dt>DOCUMENT_NODE</dt>
+     * <dd><code>Document</code>
+     * nodes cannot be imported.</dd>
+     * <dt>DOCUMENT_TYPE_NODE</dt>
+     * <dd><code>DocumentType</code>
+     * nodes cannot be imported.</dd>
+     * <dt>ELEMENT_NODE</dt>
+     * <dd>Specified attribute nodes of the
+     * source element are imported, and the generated <code>Attr</code>
+     * nodes are attached to the generated <code>Element</code>. Default
+     * attributes are not copied, though if the document being imported into
+     * defines default attributes for this element name, those are assigned.
+     * If the <code>importNode</code> <code>deep</code> parameter was set to
+     * <code>true</code>, the descendants of the source element are
+     * recursively imported and the resulting nodes reassembled to form the
+     * corresponding subtree.</dd>
+     * <dt>ENTITY_NODE</dt>
+     * <dd><code>Entity</code> nodes can be
+     * imported, however in the current release of the DOM the
+     * <code>DocumentType</code> is readonly. Ability to add these imported
+     * nodes to a <code>DocumentType</code> will be considered for addition
+     * to a future release of the DOM.On import, the <code>publicId</code>,
+     * <code>systemId</code>, and <code>notationName</code> attributes are
+     * copied. If a <code>deep</code> import is requested, the descendants
+     * of the the source <code>Entity</code> are recursively imported and
+     * the resulting nodes reassembled to form the corresponding subtree.</dd>
+     * <dt>
+     * ENTITY_REFERENCE_NODE</dt>
+     * <dd>Only the <code>EntityReference</code> itself is
+     * copied, even if a <code>deep</code> import is requested, since the
+     * source and destination documents might have defined the entity
+     * differently. If the document being imported into provides a
+     * definition for this entity name, its value is assigned.</dd>
+     * <dt>NOTATION_NODE</dt>
+     * <dd>
+     * <code>Notation</code> nodes can be imported, however in the current
+     * release of the DOM the <code>DocumentType</code> is readonly. Ability
+     * to add these imported nodes to a <code>DocumentType</code> will be
+     * considered for addition to a future release of the DOM.On import, the
+     * <code>publicId</code> and <code>systemId</code> attributes are copied.
+     * Note that the <code>deep</code> parameter has no effect on
+     * <code>Notation</code> nodes since they never have any children.</dd>
+     * <dt>
+     * PROCESSING_INSTRUCTION_NODE</dt>
+     * <dd>The imported node copies its
+     * <code>target</code> and <code>data</code> values from those of the
+     * source node.</dd>
+     * <dt>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE</dt>
+     * <dd>These three
+     * types of nodes inheriting from <code>CharacterData</code> copy their
+     * <code>data</code> and <code>length</code> attributes from those of
+     * the source node.</dd>
+     * </dl>
+     *
+     * @param importedNode The node to import.
+     * @param deep         If <code>true</code>, recursively import the subtree under
+     *                     the specified node; if <code>false</code>, import only the node
+     *                     itself, as explained above. This has no effect on <code>Attr</code>
+     *                     , <code>EntityReference</code>, and <code>Notation</code> nodes.
+     * @return The imported node that belongs to this <code>Document</code>.
+     * @throws DOMException NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
+     *                      supported.
+     * @since DOM Level 2
+     */
+    public Node importNode(Node importedNode, boolean deep) throws DOMException {
         return document.importNode(importedNode, deep);
     }
 
-    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 <code>Element</code> object with the following
+     *         attributes:
+     *         <table border='1' summary="Description of attributes and values for the new Element object">
+     *         <tr>
+     *         <th>Attribute</th>
+     *         <th>Value</th>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.nodeName</code></td>
+     *         <td valign='top'>
+     *         <code>qualifiedName</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.namespaceURI</code></td>
+     *         <td valign='top'>
+     *         <code>namespaceURI</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.prefix</code></td>
+     *         <td valign='top'>prefix, extracted
+     *         from <code>qualifiedName</code>, or <code>null</code> if there is
+     *         no prefix</td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.localName</code></td>
+     *         <td valign='top'>local name, extracted from
+     *         <code>qualifiedName</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Element.tagName</code></td>
+     *         <td valign='top'>
+     *         <code>qualifiedName</code></td>
+     *         </tr>
+     *         </table>
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name
+     *                      contains an illegal character, per the XML 1.0 specification .
+     *                      <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
+     *                      malformed per the Namespaces in XML specification, if the
+     *                      <code>qualifiedName</code> has a prefix and the
+     *                      <code>namespaceURI</code> is <code>null</code>, or if the
+     *                      <code>qualifiedName</code> has a prefix that is "xml" and the
+     *                      <code>namespaceURI</code> is different from "
+     *                      http://www.w3.org/XML/1998/namespace" .
+     *                      <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
+     *                      support the <code>"XML"</code> feature, since namespaces were
+     *                      defined by XML.
+     * @since DOM Level 2
+     */
+    public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException {
         return document.createElementNS(namespaceURI, qualifiedName);
     }
 
-    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 <code>Attr</code> object with the following attributes:
+     *         <table border='1' summary="Description of attributes and values for the new Attr object">
+     *         <tr>
+     *         <th>
+     *         Attribute</th>
+     *         <th>Value</th>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.nodeName</code></td>
+     *         <td valign='top'>qualifiedName</td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'>
+     *         <code>Node.namespaceURI</code></td>
+     *         <td valign='top'><code>namespaceURI</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'>
+     *         <code>Node.prefix</code></td>
+     *         <td valign='top'>prefix, extracted from
+     *         <code>qualifiedName</code>, or <code>null</code> if there is no
+     *         prefix</td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.localName</code></td>
+     *         <td valign='top'>local name, extracted from
+     *         <code>qualifiedName</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Attr.name</code></td>
+     *         <td valign='top'>
+     *         <code>qualifiedName</code></td>
+     *         </tr>
+     *         <tr>
+     *         <td valign='top'><code>Node.nodeValue</code></td>
+     *         <td valign='top'>the empty
+     *         string</td>
+     *         </tr>
+     *         </table>
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified qualified name
+     *                      contains an illegal character, per the XML 1.0 specification .
+     *                      <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is
+     *                      malformed per the Namespaces in XML specification, if the
+     *                      <code>qualifiedName</code> has a prefix and the
+     *                      <code>namespaceURI</code> is <code>null</code>, if the
+     *                      <code>qualifiedName</code> has a prefix that is "xml" and the
+     *                      <code>namespaceURI</code> is different from "
+     *                      http://www.w3.org/XML/1998/namespace", or if the
+     *                      <code>qualifiedName</code>, or its prefix, is "xmlns" and the
+     *                      <code>namespaceURI</code> is different from "
+     *                      http://www.w3.org/2000/xmlns/".
+     *                      <br>NOT_SUPPORTED_ERR: Always thrown if the current document does not
+     *                      support the <code>"XML"</code> feature, since namespaces were
+     *                      defined by XML.
+     * @since DOM Level 2
+     */
+    public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException {
         return document.createAttributeNS(namespaceURI, qualifiedName);
     }
 
-    public NodeList getElementsByTagNameNS(String namespaceURI,
-                                           String localName) {
+    /**
+     * Returns a <code>NodeList</code> of all the <code>Elements</code> with a
+     * given local name and namespace URI in the order in which they are
+     * encountered in a preorder traversal of the <code>Document</code> tree.
+     *
+     * @param namespaceURI The namespace URI of the elements to match on. The
+     *                     special value "*" matches all namespaces.
+     * @param localName    The local name of the elements to match on. The
+     *                     special value "*" matches all local names.
+     * @return A new <code>NodeList</code> object containing all the matched
+     *         <code>Elements</code>.
+     * @since DOM Level 2
+     */
+    public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
         return document.getElementsByTagNameNS(namespaceURI, localName);
     }
 
+    /**
+     * Returns the <code>Element</code> whose <code>ID</code> is given by
+     * <code>elementId</code>. If no such element exists, returns
+     * <code>null</code>. Behavior is not defined if more than one element
+     * has this <code>ID</code>. The DOM implementation must have
+     * information that says which attributes are of type ID. Attributes
+     * with the name "ID" are not of type ID unless so defined.
+     * Implementations that do not know whether attributes are of type ID or
+     * not are expected to return <code>null</code>.
+     *
+     * @param elementId The unique <code>id</code> value for an element.
+     * @return The matching element.
+     * @since DOM Level 2
+     */
     public Element getElementById(String elementId) {
         return document.getElementById(elementId);
     }
 
-    public String getInputEncoding() {
-        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 <code>null</code>, setting it has no effect.
+     *
+     * @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
+     * @throws DOMException DOMSTRING_SIZE_ERR: Raised when it would return more characters than
+     *                      fit in a <code>DOMString</code> variable on the implementation
+     *                      platform.
+     */
     public String getNodeValue() throws DOMException {
         return document.getNodeValue();
     }
 
-    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 <code>null</code>, setting it has no effect.
+     *
+     * @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
+     * @throws DOMException DOMSTRING_SIZE_ERR: Raised when it would return more characters than
+     *                      fit in a <code>DOMString</code> variable on the implementation
+     *                      platform.
+     */
+    public void setNodeValue(String arg0) throws DOMException {
+        document.setNodeValue(arg0);
     }
 
+    /**
+     * A code representing the type of the underlying object, as defined above.
+     */
     public short getNodeType() {
         return document.getNodeType();
     }
 
+    /**
+     * The parent of this node. All nodes, except <code>Attr</code>,
+     * <code>Document</code>, <code>DocumentFragment</code>,
+     * <code>Entity</code>, and <code>Notation</code> may have a parent.
+     * However, if a node has just been created and not yet added to the
+     * tree, or if it has been removed from the tree, this is
+     * <code>null</code>.
+     */
     public Node getParentNode() {
         return document.getParentNode();
     }
 
+    /**
+     * A <code>NodeList</code> that contains all children of this node. If
+     * there are no children, this is a <code>NodeList</code> containing no
+     * nodes.
+     */
     public NodeList getChildNodes() {
         return document.getChildNodes();
     }
 
+    /**
+     * The first child of this node. If there is no such node, this returns
+     * <code>null</code>.
+     */
     public Node getFirstChild() {
         return document.getFirstChild();
     }
 
+    /**
+     * The last child of this node. If there is no such node, this returns
+     * <code>null</code>.
+     */
     public Node getLastChild() {
         return document.getLastChild();
     }
 
+    /**
+     * The node immediately preceding this node. If there is no such node,
+     * this returns <code>null</code>.
+     */
     public Node getPreviousSibling() {
         return document.getPreviousSibling();
     }
 
+    /**
+     * The node immediately following this node. If there is no such node,
+     * this returns <code>null</code>.
+     */
     public Node getNextSibling() {
         return document.getNextSibling();
     }
 
+    /**
+     * A <code>NamedNodeMap</code> containing the attributes of this node (if
+     * it is an <code>Element</code>) or <code>null</code> otherwise.
+     */
     public NamedNodeMap getAttributes() {
         return document.getAttributes();
     }
 
+    /**
+     * The <code>Document</code> object associated with this node. This is
+     * also the <code>Document</code> object used to create new nodes. When
+     * this node is a <code>Document</code> or a <code>DocumentType</code>
+     * which is not used with any <code>Document</code> yet, this is
+     * <code>null</code>.
+     */
     public Document getOwnerDocument() {
         return document.getOwnerDocument();
     }
 
+    /**
+     * Inserts the node <code>newChild</code> before the existing child node
+     * <code>refChild</code>. If <code>refChild</code> is <code>null</code>,
+     * insert <code>newChild</code> at the end of the list of children.
+     * <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
+     * all of its children are inserted, in the same order, before
+     * <code>refChild</code>. If the <code>newChild</code> is already in the
+     * tree, it is first removed.
+     *
+     * @param newChild The node to insert.
+     * @param refChild The reference node, i.e., the node before which the
+     *                 new node must be inserted.
+     * @return The node being inserted.
+     * @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
+     *                      allow children of the type of the <code>newChild</code> node, or if
+     *                      the node to insert is one of this node's ancestors or this node
+     *                      itself.
+     *                      <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
+     *                      from a different document than the one that created this node.
+     *                      <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
+     *                      if the parent of the node being inserted is readonly.
+     *                      <br>NOT_FOUND_ERR: Raised if <code>refChild</code> is not a child of
+     *                      this node.
+     */
     public Node insertBefore(Node newChild, Node refChild) throws DOMException {
         return document.insertBefore(newChild, refChild);
     }
 
+    /**
+     * Replaces the child node <code>oldChild</code> with <code>newChild</code>
+     * in the list of children, and returns the <code>oldChild</code> node.
+     * <br>If <code>newChild</code> is a <code>DocumentFragment</code> object,
+     * <code>oldChild</code> is replaced by all of the
+     * <code>DocumentFragment</code> children, which are inserted in the
+     * same order. If the <code>newChild</code> is already in the tree, it
+     * is first removed.
+     *
+     * @param newChild The new node to put in the child list.
+     * @param oldChild The node being replaced in the list.
+     * @return The node replaced.
+     * @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
+     *                      allow children of the type of the <code>newChild</code> node, or if
+     *                      the node to put in is one of this node's ancestors or this node
+     *                      itself.
+     *                      <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
+     *                      from a different document than the one that created this node.
+     *                      <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of
+     *                      the new node is readonly.
+     *                      <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
+     *                      this node.
+     */
     public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
         return document.replaceChild(newChild, oldChild);
     }
 
+    /**
+     * Removes the child node indicated by <code>oldChild</code> from the list
+     * of children, and returns it.
+     *
+     * @param oldChild The node being removed.
+     * @return The node removed.
+     * @throws DOMException NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
+     *                      <br>NOT_FOUND_ERR: Raised if <code>oldChild</code> is not a child of
+     *                      this node.
+     */
     public Node removeChild(Node oldChild) throws DOMException {
         return document.removeChild(oldChild);
     }
 
+    /**
+     * Adds the node <code>newChild</code> to the end of the list of children
+     * of this node. If the <code>newChild</code> is already in the tree, it
+     * is first removed.
+     *
+     * @param newChild The node to add.If it is a
+     *                 <code>DocumentFragment</code> object, the entire contents of the
+     *                 document fragment are moved into the child list of this node
+     * @return The node added.
+     * @throws DOMException HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
+     *                      allow children of the type of the <code>newChild</code> node, or if
+     *                      the node to append is one of this node's ancestors or this node
+     *                      itself.
+     *                      <br>WRONG_DOCUMENT_ERR: Raised if <code>newChild</code> was created
+     *                      from a different document than the one that created this node.
+     *                      <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
+     *                      if the previous parent of the node being inserted is readonly.
+     */
     public Node appendChild(Node newChild) throws DOMException {
         return document.appendChild(newChild);
     }
 
+    /**
+     * Returns whether this node has any children.
+     *
+     * @return <code>true</code> if this node has any children,
+     *         <code>false</code> otherwise.
+     */
     public boolean hasChildNodes() {
         return document.hasChildNodes();
     }
 
+    /**
+     * Returns a duplicate of this node, i.e., serves as a generic copy
+     * constructor for nodes. The duplicate node has no parent; (
+     * <code>parentNode</code> is <code>null</code>.).
+     * <br>Cloning an <code>Element</code> copies all attributes and their
+     * values, including those generated by the XML processor to represent
+     * defaulted attributes, but this method does not copy any text it
+     * contains unless it is a deep clone, since the text is contained in a
+     * child <code>Text</code> node. Cloning an <code>Attribute</code>
+     * directly, as opposed to be cloned as part of an <code>Element</code>
+     * cloning operation, returns a specified attribute (
+     * <code>specified</code> is <code>true</code>). Cloning any other type
+     * of node simply returns a copy of this node.
+     * <br>Note that cloning an immutable subtree results in a mutable copy,
+     * but the children of an <code>EntityReference</code> clone are readonly
+     * . In addition, clones of unspecified <code>Attr</code> nodes are
+     * specified. And, cloning <code>Document</code>,
+     * <code>DocumentType</code>, <code>Entity</code>, and
+     * <code>Notation</code> nodes is implementation dependent.
+     *
+     * @param deep If <code>true</code>, recursively clone the subtree under
+     *             the specified node; if <code>false</code>, clone only the node
+     *             itself (and its attributes, if it is an <code>Element</code>).
+     * @return The duplicate node.
+     */
     public Node cloneNode(boolean deep) {
         return document.cloneNode(deep);
     }
 
+    /**
+     * Puts all <code>Text</code> nodes in the full depth of the sub-tree
+     * underneath this <code>Node</code>, including attribute nodes, into a
+     * "normal" form where only structure (e.g., elements, comments,
+     * processing instructions, CDATA sections, and entity references)
+     * separates <code>Text</code> nodes, i.e., there are neither adjacent
+     * <code>Text</code> nodes nor empty <code>Text</code> nodes. This can
+     * be used to ensure that the DOM view of a document is the same as if
+     * it were saved and re-loaded, and is useful when operations (such as
+     * XPointer  lookups) that depend on a particular document tree
+     * structure are to be used.In cases where the document contains
+     * <code>CDATASections</code>, the normalize operation alone may not be
+     * sufficient, since XPointers do not differentiate between
+     * <code>Text</code> nodes and <code>CDATASection</code> nodes.
+     */
     public void normalize() {
         document.normalize();
     }
 
+    /**
+     * Tests whether the DOM implementation implements a specific feature and
+     * that feature is supported by this node.
+     *
+     * @param feature The name of the feature to test. This is the same name
+     *                which can be passed to the method <code>hasFeature</code> on
+     *                <code>DOMImplementation</code>.
+     * @param version This is the version number of the feature to test. In
+     *                Level 2, version 1, this is the string "2.0". If the version is not
+     *                specified, supporting any version of the feature will cause the
+     *                method to return <code>true</code>.
+     * @return Returns <code>true</code> if the specified feature is
+     *         supported on this node, <code>false</code> otherwise.
+     * @since DOM Level 2
+     */
     public boolean isSupported(String feature, String version) {
         return document.isSupported(feature, version);
     }
 
+    /**
+     * The namespace URI of this node, or <code>null</code> if it is
+     * unspecified.
+     * <br>This is not a computed value that is the result of a namespace
+     * lookup based on an examination of the namespace declarations in
+     * scope. It is merely the namespace URI given at creation time.
+     * <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
+     * <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
+     * method, such as <code>createElement</code> from the
+     * <code>Document</code> interface, this is always <code>null</code>.Per
+     * the Namespaces in XML Specification  an attribute does not inherit
+     * its namespace from the element it is attached to. If an attribute is
+     * not explicitly given a namespace, it simply has no namespace.
+     *
+     * @since DOM Level 2
+     */
     public String getNamespaceURI() {
         return document.getNamespaceURI();
     }
 
+    /**
+     * The namespace prefix of this node, or <code>null</code> if it is
+     * unspecified.
+     * <br>Note that setting this attribute, when permitted, changes the
+     * <code>nodeName</code> attribute, which holds the qualified name, as
+     * well as the <code>tagName</code> and <code>name</code> attributes of
+     * the <code>Element</code> and <code>Attr</code> interfaces, when
+     * applicable.
+     * <br>Note also that changing the prefix of an attribute that is known to
+     * have a default value, does not make a new attribute with the default
+     * value and the original prefix appear, since the
+     * <code>namespaceURI</code> and <code>localName</code> do not change.
+     * <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
+     * <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
+     * method, such as <code>createElement</code> from the
+     * <code>Document</code> interface, this is always <code>null</code>.
+     *
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
+     *                      illegal character, per the XML 1.0 specification .
+     *                      <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
+     *                      <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
+     *                      malformed per the Namespaces in XML specification, if the
+     *                      <code>namespaceURI</code> of this node is <code>null</code>, if the
+     *                      specified prefix is "xml" and the <code>namespaceURI</code> of this
+     *                      node is different from "http://www.w3.org/XML/1998/namespace", if
+     *                      this node is an attribute and the specified prefix is "xmlns" and
+     *                      the <code>namespaceURI</code> of this node is different from "
+     *                      http://www.w3.org/2000/xmlns/", or if this node is an attribute and
+     *                      the <code>qualifiedName</code> of this node is "xmlns" .
+     * @since DOM Level 2
+     */
     public String getPrefix() {
         return document.getPrefix();
     }
 
-    public void setPrefix(String prefix) throws DOMException {
-        document.setPrefix(prefix);
+    /**
+     * The namespace prefix of this node, or <code>null</code> if it is
+     * unspecified.
+     * <br>Note that setting this attribute, when permitted, changes the
+     * <code>nodeName</code> attribute, which holds the qualified name, as
+     * well as the <code>tagName</code> and <code>name</code> attributes of
+     * the <code>Element</code> and <code>Attr</code> interfaces, when
+     * applicable.
+     * <br>Note also that changing the prefix of an attribute that is known to
+     * have a default value, does not make a new attribute with the default
+     * value and the original prefix appear, since the
+     * <code>namespaceURI</code> and <code>localName</code> do not change.
+     * <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
+     * <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
+     * method, such as <code>createElement</code> from the
+     * <code>Document</code> interface, this is always <code>null</code>.
+     *
+     * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
+     *                      illegal character, per the XML 1.0 specification .
+     *                      <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
+     *                      <br>NAMESPACE_ERR: Raised if the specified <code>prefix</code> is
+     *                      malformed per the Namespaces in XML specification, if the
+     *                      <code>namespaceURI</code> of this node is <code>null</code>, if the
+     *                      specified prefix is "xml" and the <code>namespaceURI</code> of this
+     *                      node is different from "http://www.w3.org/XML/1998/namespace", if
+     *                      this node is an attribute and the specified prefix is "xmlns" and
+     *                      the <code>namespaceURI</code> of this node is different from "
+     *                      http://www.w3.org/2000/xmlns/", or if this node is an attribute and
+     *                      the <code>qualifiedName</code> of this node is "xmlns" .
+     * @since DOM Level 2
+     */
+    public void setPrefix(String arg0) throws DOMException {
+        document.setPrefix(arg0);
     }
 
+    /**
+     * Returns the local part of the qualified name of this node.
+     * <br>For nodes of any type other than <code>ELEMENT_NODE</code> and
+     * <code>ATTRIBUTE_NODE</code> and nodes created with a DOM Level 1
+     * method, such as <code>createElement</code> from the
+     * <code>Document</code> interface, this is always <code>null</code>.
+     *
+     * @since DOM Level 2
+     */
     public String getLocalName() {
         return document.getLocalName();
     }
 
+    /**
+     * Returns whether this node (if it is an element) has any attributes.
+     *
+     * @return <code>true</code> if this node has any attributes,
+     *         <code>false</code> otherwise.
+     * @since DOM Level 2
+     */
     public boolean hasAttributes() {
         return document.hasAttributes();
     }
 
-    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 <CODE>Text</CODE> object
+     * represents a comment.
+     *
+     * @return <CODE>true</CODE> if this <CODE>Text</CODE> object is
+     *         a comment; <CODE>false</CODE> otherwise
+     */
+    public boolean isComment() {
+        String value = textNode.getText();
+        return value.startsWith("<!--") && value.endsWith("-->");
+    }
+
+    /**
+     * 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 <code>offset</code>,
+     * keeping both in the tree as siblings. After being split, this node
+     * will contain all the content up to the <code>offset</code> point. A
+     * new node of the same type, which contains all the content at and
+     * after the <code>offset</code> 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 <code>offset</code> 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
+     *               <code>0</code>.
+     * @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 <code>data</code>.
+     *                      <br>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 <code>CharacterData</code> node. However,
+     * implementation limits may mean that the entirety of a node's data may
+     * not fit into a single <code>DOMString</code>. In such cases, the user
+     * may call <code>substringData</code> 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 <code>DOMString</code> 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 <code>CharacterData</code> node. However,
+     * implementation limits may mean that the entirety of a node's data may
+     * not fit into a single <code>DOMString</code>. In such cases, the user
+     * may call <code>substringData</code> 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 <code>DOMString</code> 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 <code>offset</code> and
+     *         <code>count</code> exceeds the <code>length</code>, then all 16-bit
+     *         units to the end of the data are returned.
+     * @throws DOMException INDEX_SIZE_ERR: Raised if the specified <code>offset</code> is
+     *                      negative or greater than the number of 16-bit units in
+     *                      <code>data</code>, or if the specified <code>count</code> is
+     *                      negative.
+     *                      <br>DOMSTRING_SIZE_ERR: Raised if the specified range of text does
+     *                      not fit into a <code>DOMString</code>.
+     */
+    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, <code>data</code> provides access to the concatenation of
+     * <code>data</code> and the <code>DOMString</code> specified.
+     *
+     * @param value The <code>DOMString</code> 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 <code>DOMString</code> to insert.
+     * @throws DOMException INDEX_SIZE_ERR: Raised if the specified <code>offset</code> is
+     *                      negative or greater than the number of 16-bit units in
+     *                      <code>data</code>.
+     *                      <br>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,
+     * <code>data</code> and <code>length</code> 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
+     *               <code>offset</code> and <code>count</code> exceeds
+     *               <code>length</code> then all 16-bit units from <code>offset</code>
+     *               to the end of the data are deleted.
+     * @throws DOMException INDEX_SIZE_ERR: Raised if the specified <code>offset</code> is
+     *                      negative or greater than the number of 16-bit units in
+     *                      <code>data</code>, or if the specified <code>count</code> is
+     *                      negative.
+     *                      <br>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
+     *               <code>offset</code> and <code>count</code> exceeds
+     *               <code>length</code>, then all 16-bit units to the end of the data
+     *               are replaced; (i.e., the effect is the same as a <code>remove</code>
+     *               method call with the same range, followed by an <code>append</code>
+     *               method invocation).
+     * @param data   The <code>DOMString</code> with which the range must be
+     *               replaced.
+     * @throws DOMException INDEX_SIZE_ERR: Raised if the specified <code>offset</code> is
+     *                      negative or greater than the number of 16-bit units in
+     *                      <code>data</code>, or if the specified <code>count</code> is
+     *                      negative.
+     *                      <br>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();



Mime
View raw message