axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ruchi...@apache.org
Subject svn commit: r358784 [3/4] - in /webservices/axis2/trunk/archive/java/scratch/ruchith_dims/saaj2: src/org/apache/axis2/saaj2/ test-resources/ test/org/apache/axis2/saaj2/
Date Fri, 23 Dec 2005 09:40:56 GMT
Modified: webservices/axis2/trunk/archive/java/scratch/ruchith_dims/saaj2/src/org/apache/axis2/saaj2/SOAPMessageImpl.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/archive/java/scratch/ruchith_dims/saaj2/src/org/apache/axis2/saaj2/SOAPMessageImpl.java?rev=358784&r1=358783&r2=358784&view=diff
==============================================================================
--- webservices/axis2/trunk/archive/java/scratch/ruchith_dims/saaj2/src/org/apache/axis2/saaj2/SOAPMessageImpl.java (original)
+++ webservices/axis2/trunk/archive/java/scratch/ruchith_dims/saaj2/src/org/apache/axis2/saaj2/SOAPMessageImpl.java Fri Dec 23 01:40:17 2005
@@ -15,40 +15,373 @@
  */
 package org.apache.axis2.saaj2;
 
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.ArrayList;
-import java.util.Iterator;
+import org.apache.axis2.om.OMOutputFormat;
+import org.apache.axis2.transport.http.HTTPConstants;
 
 import javax.xml.soap.AttachmentPart;
-import javax.xml.soap.MimeHeaders;
+import javax.xml.soap.MimeHeader;
 import javax.xml.soap.SOAPException;
 import javax.xml.soap.SOAPMessage;
 import javax.xml.soap.SOAPPart;
+import javax.xml.soap.SOAPHeader;
+import javax.xml.soap.SOAPBody;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
 
 public class SOAPMessageImpl extends SOAPMessage {
 
-	
-    private SOAPPartImpl mSOAPPart;
-    private ArrayList attachments = new ArrayList();
-    private java.util.Hashtable mProps = new java.util.Hashtable();
-    private MimeHeadersEx headers;
-	
-    
-    
-    
-	private void setup(Object initialContents, String contentType, String contentLocation,
-            MimeHeaders mimeHeaders) throws SOAPException {
-        if(contentType == null && mimeHeaders != null) {
+    private SOAPPart soapPart;
+    private Collection attachmentParts = new ArrayList();
+    private MimeHeadersEx mimeHeaders;
+
+    private Map props = new Hashtable();
+
+    public SOAPMessageImpl(SOAPEnvelopeImpl soapEnvelope) {
+        String contentType = null;
+        if (mimeHeaders != null) {
             String contentTypes[] = mimeHeaders.getHeader("Content-Type");
-            contentType = (contentTypes != null)? contentTypes[0] : null;
+            contentType = (contentTypes != null) ? contentTypes[0] : null;
         }
 
-        if(contentLocation == null && mimeHeaders != null) {
-            String contentLocations[] = mimeHeaders.getHeader("Content-Location");
-            contentLocation = (contentLocations != null)? contentLocations[0] : null;
+        setCharsetEncoding(contentType);
+
+        soapPart = new SOAPPartImpl(this, soapEnvelope);
+
+        this.mimeHeaders = new MimeHeadersEx();
+    }
+
+    public SOAPMessageImpl(InputStream inputstream,
+                           javax.xml.soap.MimeHeaders mimeHeaders) throws SOAPException {
+        String contentType = null;
+        if (mimeHeaders != null) {
+            String contentTypes[] = mimeHeaders.getHeader("Content-Type");
+            contentType = (contentTypes != null) ? contentTypes[0] : null;
+        }
+
+        setCharsetEncoding(contentType);
+        soapPart = new SOAPPartImpl(this, inputstream);
+
+        this.mimeHeaders = (mimeHeaders == null) ?
+                           new MimeHeadersEx() :
+                           new MimeHeadersEx(mimeHeaders);
+    }
+
+    /**
+     * Retrieves a description of this <CODE>SOAPMessage</CODE>
+     * object's content.
+     *
+     * @return a <CODE>String</CODE> describing the content of this
+     *         message or <CODE>null</CODE> if no description has been
+     *         set
+     * @see #setContentDescription(java.lang.String) setContentDescription(java.lang.String)
+     */
+    public String getContentDescription() {
+        String values[] = mimeHeaders.getHeader(HTTPConstants.HEADER_CONTENT_DESCRIPTION);
+        if (values != null && values.length > 0) {
+            return values[0];
         }
+        return null;
+    }
 
+    /**
+     * Sets the description of this <CODE>SOAPMessage</CODE>
+     * object's content with the given description.
+     *
+     * @param description a <CODE>String</CODE>
+     *                    describing the content of this message
+     * @see #getContentDescription() getContentDescription()
+     */
+    public void setContentDescription(String description) {
+        mimeHeaders.setHeader(HTTPConstants.HEADER_CONTENT_DESCRIPTION, description);
+    }
+
+    /**
+     * Gets the SOAP part of this <CODE>SOAPMessage</CODE> object.
+     * <p/>
+     * <p/>
+     * <P>If a <CODE>SOAPMessage</CODE> object contains one or
+     * more attachments, the SOAP Part must be the first MIME body
+     * part in the message.</P>
+     *
+     * @return the <CODE>SOAPPart</CODE> object for this <CODE>
+     *         SOAPMessage</CODE> object
+     */
+    public SOAPPart getSOAPPart() {
+        return soapPart;
+    }
+
+    /**
+     * Removes all <CODE>AttachmentPart</CODE> objects that have
+     * been added to this <CODE>SOAPMessage</CODE> object.
+     * <p/>
+     * <P>This method does not touch the SOAP part.</P>
+     */
+    public void removeAllAttachments() {
+        attachmentParts.clear();
+    }
+
+    /**
+     * Gets a count of the number of attachments in this
+     * message. This count does not include the SOAP part.
+     *
+     * @return the number of <CODE>AttachmentPart</CODE> objects
+     *         that are part of this <CODE>SOAPMessage</CODE>
+     *         object
+     */
+    public int countAttachments() {
+        return attachmentParts.size();
+    }
+
+    /**
+     * Retrieves all the <CODE>AttachmentPart</CODE> objects
+     * that are part of this <CODE>SOAPMessage</CODE> object.
+     *
+     * @return an iterator over all the attachments in this
+     *         message
+     */
+    public Iterator getAttachments() {
+        return attachmentParts.iterator();
+    }
+
+    /**
+     * Retrieves all the AttachmentPart objects that have header entries that match the specified
+     * headers.
+     * Note that a returned attachment could have headers in addition to those specified.
+     *
+     * @param headers a {@link javax.xml.soap.MimeHeaders}
+     *                object containing the MIME headers for which to search
+     * @return an iterator over all attachments({@link javax.xml.soap.AttachmentPart})
+     *         that have a header that matches one of the given headers
+     */
+    public Iterator getAttachments(javax.xml.soap.MimeHeaders headers) {
+        Collection matchingAttachmentParts = new ArrayList();
+        Iterator iterator = getAttachments();
+        {
+            AttachmentPartImpl part;
+            while (iterator.hasNext()) {
+                part = (AttachmentPartImpl) iterator.next();
+                if (part.matches(headers)) {
+                    matchingAttachmentParts.add(part);
+                }
+            }
+        }
+        return matchingAttachmentParts.iterator();
+    }
+
+    /**
+     * Adds the given <CODE>AttachmentPart</CODE> object to this
+     * <CODE>SOAPMessage</CODE> object. An <CODE>
+     * AttachmentPart</CODE> object must be created before it can be
+     * added to a message.
+     *
+     * @param attachmentPart an <CODE>
+     *                       AttachmentPart</CODE> object that is to become part of
+     *                       this <CODE>SOAPMessage</CODE> object
+     * @throws java.lang.IllegalArgumentException
+     *
+     */
+    public void addAttachmentPart(AttachmentPart attachmentPart) {
+        if (attachmentPart != null) {
+            attachmentParts.add(attachmentPart);
+            mimeHeaders.setHeader("Content-Type", "multipart/related");
+        }
+    }
+
+    /**
+     * Creates a new empty <CODE>AttachmentPart</CODE> object.
+     * Note that the method <CODE>addAttachmentPart</CODE> must be
+     * called with this new <CODE>AttachmentPart</CODE> object as
+     * the parameter in order for it to become an attachment to this
+     * <CODE>SOAPMessage</CODE> object.
+     *
+     * @return a new <CODE>AttachmentPart</CODE> object that can be
+     *         populated and added to this <CODE>SOAPMessage</CODE>
+     *         object
+     */
+    public AttachmentPart createAttachmentPart() {
+        return new AttachmentPartImpl();
+    }
+
+    /**
+     * Returns all the transport-specific MIME headers for this
+     * <CODE>SOAPMessage</CODE> object in a transport-independent
+     * fashion.
+     *
+     * @return a <CODE>MimeHeaders</CODE> object containing the
+     *         <CODE>MimeHeader</CODE> objects
+     */
+    public javax.xml.soap.MimeHeaders getMimeHeaders() {
+        return mimeHeaders;
+    }
+
+    /**
+     * Updates this <CODE>SOAPMessage</CODE> object with all the
+     * changes that have been made to it. This method is called
+     * automatically when a message is sent or written to by the
+     * methods <CODE>ProviderConnection.send</CODE>, <CODE>
+     * SOAPConnection.call</CODE>, or <CODE>
+     * SOAPMessage.writeTo</CODE>. However, if changes are made to
+     * a message that was received or to one that has already been
+     * sent, the method <CODE>saveChanges</CODE> needs to be
+     * called explicitly in order to save the changes. The method
+     * <CODE>saveChanges</CODE> also generates any changes that
+     * can be read back (for example, a MessageId in profiles that
+     * support a message id). All MIME headers in a message that
+     * is created for sending purposes are guaranteed to have
+     * valid values only after <CODE>saveChanges</CODE> has been
+     * called.
+     * <p/>
+     * <P>In addition, this method marks the point at which the
+     * data from all constituent <CODE>AttachmentPart</CODE>
+     * objects are pulled into the message.</P>
+     *
+     * @throws SOAPException if there was a problem saving changes to this message.
+     */
+    public void saveChanges() throws SOAPException {
+        // TODO not sure of the implementation
+        throw new UnsupportedOperationException("TODO");
+    }
+
+    /**
+     * Indicates whether this <CODE>SOAPMessage</CODE> object
+     * has had the method {@link #saveChanges()} called on
+     * it.
+     *
+     * @return <CODE>true</CODE> if <CODE>saveChanges</CODE> has
+     *         been called on this message at least once; <CODE>
+     *         false</CODE> otherwise.
+     */
+    public boolean saveRequired() {
+        return false;
+    }
+
+    /**
+     * Writes this <CODE>SOAPMessage</CODE> object to the given
+     * output stream. The externalization format is as defined by
+     * the SOAP 1.1 with Attachments specification.
+     * <p/>
+     * <P>If there are no attachments, just an XML stream is
+     * written out. For those messages that have attachments,
+     * <CODE>writeTo</CODE> writes a MIME-encoded byte stream.</P>
+     *
+     * @param out the <CODE>OutputStream</CODE>
+     *            object to which this <CODE>SOAPMessage</CODE> object will
+     *            be written
+     * @throws SOAPException if there was a problem in externalizing this SOAP message
+     * @throws IOException   if an I/O error occurs
+     */
+    public void writeTo(OutputStream out) throws SOAPException, IOException {
+        try {
+            OMOutputFormat format = new OMOutputFormat();
+            format.setCharSetEncoding((String) getProperty(CHARACTER_SET_ENCODING));
+            String writeXmlDecl = (String) getProperty(WRITE_XML_DECLARATION);
+            if (writeXmlDecl == null || writeXmlDecl.equals("false")) {
+
+                //SAAJ default case doesn't send XML decl
+                format.setIgnoreXMLDeclaration(true);
+            }
+
+            //the writeTo method forces the elements to be built!!!
+            ((SOAPEnvelopeImpl) soapPart.getEnvelope()).getOMEnvelope().serialize(out, format);
+        } catch (Exception e) {
+            throw new SOAPException(e);
+        }
+    }
+
+    /**
+     * Associates the specified value with the specified property. If there was
+     * already a value associated with this property, the old value is replaced.
+     * <p/>
+     * The valid property names include <code>WRITE_XML_DECLARATION</code> and
+     * <code>CHARACTER_SET_ENCODING</code>. All of these standard SAAJ
+     * properties are prefixed by "javax.xml.soap". Vendors may also add
+     * implementation specific properties. These properties must be prefixed
+     * with package names that are unique to the vendor.
+     * <p/>
+     * Setting the property <code>WRITE_XML_DECLARATION</code> to
+     * <code>"true"</code> will cause an XML Declaration to be written out at
+     * the start of the SOAP message. The default value of "false" suppresses
+     * this declaration.
+     * <p/>
+     * The property <code>CHARACTER_SET_ENCODING</code> defaults to the value
+     * <code>"utf-8"</code> which causes the SOAP message to be encoded using
+     * UTF-8. Setting <code>CHARACTER_SET_ENCODING</code> to
+     * <code>"utf-16"</code> causes the SOAP message to be encoded using UTF-16.
+     * <p/>
+     * Some implementations may allow encodings in addition to UTF-8 and UTF-16.
+     * Refer to your vendor's documentation for details.
+     *
+     * @param property the property with which the specified value is to be
+     *                 associated
+     * @param value    the value
+     *                 to be associated with the specified property
+     */
+    public void setProperty(String property, Object value) {
+        props.put(property, value);
+    }
+
+    /**
+     * Retrieves value of the specified property.
+     *
+     * @param property the name of the property to retrieve
+     * @return the value of the property or <code>null</code> if no such
+     *         property exists
+     * @throws SOAPException if the property name is not recognized
+     */
+    public Object getProperty(String property) throws SOAPException {
+        return props.get(property);
+    }
+
+    /**
+     * Gets the SOAP Header contained in this <code>SOAPMessage</code> object.
+     *
+     * @return the <code>SOAPHeader</code> object contained by this
+     *         <code>SOAPMessage</code> object
+     * @throws javax.xml.soap.SOAPException if the SOAP Header does not exist or cannot be
+     *                                      retrieved
+     */
+    public SOAPHeader getSOAPHeader() throws SOAPException {
+        return this.soapPart.getEnvelope().getHeader();
+    }
+
+    /**
+     * Gets the SOAP Body contained in this <code>SOAPMessage</code> object.
+     *
+     * @return the <code>SOAPBody</code> object contained by this
+     *         <code>SOAPMessage</code> object
+     * @throws javax.xml.soap.SOAPException if the SOAP Body does not exist or cannot be
+     *                                      retrieved
+     */
+    public SOAPBody getSOAPBody() throws SOAPException {
+        return this.soapPart.getEnvelope().getBody();
+    }
+
+    /**
+     * Retrieve the MIME Header names by providing the {@link javax.xml.soap.MimeHeaders} Object
+     *
+     * @param headers The {@link javax.xml.soap.MimeHeaders} Object
+     * @return MIME Header names corresponding to the <code>headers</code>
+     */
+    private String[] getMimeHeaderNames(final javax.xml.soap.MimeHeaders headers) {
+        Collection mimeHeaderNames = new ArrayList();
+        for (Iterator iterator = headers.getAllHeaders(); iterator.hasNext();) {
+            mimeHeaderNames.add(((MimeHeader) iterator.next()).getName());
+        }
+        return (String[]) mimeHeaderNames.toArray(new String[0]);
+    }
+
+    /**
+     * Set the character encoding based on the <code>contentType</code> parameter
+     *
+     * @param contentType
+     */
+    private void setCharsetEncoding(final String contentType) {
         if (contentType != null) {
             int delimiterIndex = contentType.lastIndexOf("charset");
             if (delimiterIndex > 0) {
@@ -59,118 +392,10 @@
                     charset = charset.substring(1, charset.length());
                 }
                 if ((charset.endsWith("\"") || charset.endsWith("\'"))) {
-                    charset = charset.substring(0, charset.length()-1);
-                }
-                try {
-                    setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charset);
-                } catch (SOAPException e) {
+                    charset = charset.substring(0, charset.length() - 1);
                 }
+                setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charset);
             }
         }
-        
-	}
-	
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#getContentDescription()
-	 */
-	public String getContentDescription() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#setContentDescription(java.lang.String)
-	 */
-	public void setContentDescription(String description) {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#getSOAPPart()
-	 */
-	public SOAPPart getSOAPPart() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#removeAllAttachments()
-	 */
-	public void removeAllAttachments() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#countAttachments()
-	 */
-	public int countAttachments() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#getAttachments()
-	 */
-	public Iterator getAttachments() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#getAttachments(javax.xml.soap.MimeHeaders)
-	 */
-	public Iterator getAttachments(javax.xml.soap.MimeHeaders headers) {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#addAttachmentPart(javax.xml.soap.AttachmentPart)
-	 */
-	public void addAttachmentPart(AttachmentPart attachmentpart) {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#createAttachmentPart()
-	 */
-	public AttachmentPart createAttachmentPart() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#getMimeHeaders()
-	 */
-	public javax.xml.soap.MimeHeaders getMimeHeaders() {
-		return this.headers;
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#saveChanges()
-	 */
-	public void saveChanges() throws SOAPException {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#saveRequired()
-	 */
-	public boolean saveRequired() {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-
-	/* (non-Javadoc)
-	 * @see javax.xml.soap.SOAPMessage#writeTo(java.io.OutputStream)
-	 */
-	public void writeTo(OutputStream out) throws SOAPException, IOException {
-		// TODO TODO
-		throw new UnsupportedOperationException("TODO");
-	}
-	
+    }
 }

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



Mime
View raw message