Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.axis.message
Class SOAPDocumentImpl

    java.lang.Object
      org.apache.axis.message.SOAPDocumentImpl

All Implemented Interfaces:
  Document, Node, Serializable

public class SOAPDocumentImpl
extends Object
implements Document, Serializable

SOAPDcoumentImpl implements the Document API for SOAPPART. At the moment, it * again delgate the XERCES DOM Implementation Here is my argument on it: I * guess that there is 3 way to implement this. - fully implement the DOM API * here myself. => This is too much and duplicated work. - extends XERCES * Implementation => this makes we are fixed to one Implementation - choose * delgate depends on the user's parser preference => This is the practically * best solution I have now * * @author Heejune Ahn (cityboy@tmax.co.kr)

See Also:
  Serialized Form

Field Summary

Fields inherited from interface org.w3c.dom.Node
`ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE`

Constructor Summary
`SOAPDocumentImpl(MessagePart sp)` Construct the Document * * @param sp

Method Summary
`Node` | `appendChild(Node newChild)`
`Node` | `cloneNode(boolean deep)` [todo] Study it more....
`Attr` | `createAttribute(String name)`
`Attr` | `createAttributeNS(String namespaceURI, String qualifiedName)` Attribute is not particularly dealt with in SAAJ.
`CDATASection` | `createCDATASection(String data)` Creates a `CDATASection` node whose value is the specified * string.
`Comment` | `createComment(String data)` Creates a `Comment` node given the specified string.
`DocumentFragment` | `createDocumentFragment()` Creates an empty `DocumentFragment` object.
`Element` | `createElement(String tagName)` based on the tagName, we will make different kind SOAP Elements Instance * Is really we can determine the Type by the Tagname??? * * @param tagName * @return @throws * DOMException
`Element` | `createElementNS(String namespaceURI, String qualifiedName)` Return SOAPElements (what if they want SOAPEnvelope or Header/Body?) * * @param namespaceURI * @param qualifiedName * @return @throws * DOMException
`EntityReference` | `createEntityReference(String name)`
`ProcessingInstruction` | `createProcessingInstruction(String target, String data)` Creates a `ProcessingInstruction` node given the specified * name and data strings.
`Text` | `createTextNode(String data)` Creates a `Text` node given the specified string.
`NamedNodeMap` | `getAttributes()`
`NodeList` | `getChildNodes()`
`DocumentType` | `getDoctype()`
`Element` | `getDocumentElement()` should not be called, the method will be handled in SOAPPart * * @return
`Element` | `getElementById(String elementId)` Returns the `Element` whose `ID` is given by * `elementId`.
`NodeList` | `getElementsByTagName(String localName)` search the SOAPPart in order of SOAPHeader and SOAPBody for the * requested Element name
`NodeList` | `getElementsByTagNameNS(String namespaceURI, String localName)` search the SOAPPart in order of SOAPHeader and SOAPBody for the * requested Element name
`Node` | `getFirstChild()` Do we have to count the Attributes as node ???? * * @return
`DOMImplementation` | `getImplementation()`
`Node` | `getLastChild()`
`String` | `getLocalName()`
`String` | `getNamespaceURI()`
`Node` | `getNextSibling()`
`String` | `getNodeName()` Node Implementation
`short` | `getNodeType()` override it in sub-classes * * @return
`String` | `getNodeValue()`
`Document` | `getOwnerDocument()` we have to have a link to them...
`Node` | `getParentNode()`
`String` | `getPrefix()`
`Node` | `getPreviousSibling()`
`boolean` | `hasAttributes()`
`boolean` | `hasChildNodes()`
`Node` | `importNode(Node importedNode, boolean deep)`
`Node` | `insertBefore(Node newChild, Node refChild)`
`boolean` | `isSupported(String feature, String version)`
`void` | `normalize()` [todo] is it OK to simply call the superclass?
`Node` | `removeChild(Node oldChild)`
`Node` | `replaceChild(Node newChild, Node oldChild)`
`void` | `setNamespaceURI(String nsURI)`
`void` | `setNodeValue(String nodeValue)`
`void` | `setPrefix(String prefix)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### SOAPDocumentImpl

    public SOAPDocumentImpl(MessagePart sp)

  Construct the Document * * @param sp

Method Detail

### getDoctype

    public DocumentType getDoctype()

  Specified by:
    `getDoctype` in interface `Document`

### getImplementation

    public DOMImplementation getImplementation()

  Specified by:
    `getImplementation` in interface `Document`

### getDocumentElement

    public Element getDocumentElement()

  should not be called, the method will be handled in SOAPPart * * @return

  Specified by:
    `getDocumentElement` in interface `Document`

### createElement

    public Element createElement(String tagName)
                          throws DOMException

  based on the tagName, we will make different kind SOAP Elements Instance * Is really we can determine the Type by the Tagname??? * * @param tagName * @return @throws * DOMException

  Specified by:
    `createElement` in interface `Document`
  Throws:
    `DOMException`

### createDocumentFragment

    public DocumentFragment createDocumentFragment()

  Creates an empty `DocumentFragment` object. @todo not * implemented yet * * @return A new `DocumentFragment`.

  Specified by:
    `createDocumentFragment` in interface `Document`

### createTextNode

    public Text createTextNode(String data)

  Creates a `Text` node given the specified string. * * @param data The data for the node. * @return The new `Text` object.

  Specified by:
    `createTextNode` in interface `Document`

### createComment

    public Comment createComment(String data)

  Creates a `Comment` node given the specified string. * * @param data The data for the node. * @return The new `Comment` object.

  Specified by:
    `createComment` in interface `Document`

### createCDATASection

    public CDATASection createCDATASection(String data)
                                    throws DOMException

  Creates a `CDATASection` node whose value is the specified * string. * * @param data The data for the `CDATASection` contents. * @return The new `CDATASection` object. * @throws DOMException NOT_SUPPORTED_ERR: Raised if this document is an HTML * document.

  Specified by:
    `createCDATASection` in interface `Document`
  Throws:
    `DOMException`

### createProcessingInstruction

    public ProcessingInstruction createProcessingInstruction(String target,
                                                             String data)
                                                      throws DOMException

  Creates a `ProcessingInstruction` node given the specified * name and data strings. * * @param target The target part of the processing instruction. * @param data The data for the node. * @return The new `ProcessingInstruction` object. * @throws DOMException INVALID_CHARACTER_ERR: Raised if the specified target * contains an illegal character.
  NOT_SUPPORTED_ERR: * Raised if this document is an HTML document.

  Specified by:
    `createProcessingInstruction` in interface `Document`
  Throws:
    `DOMException`

### createAttribute

    public Attr createAttribute(String name)
                         throws DOMException

  Specified by:
    `createAttribute` in interface `Document`
  Throws:
    `DOMException`

### createEntityReference

    public EntityReference createEntityReference(String name)
                                          throws DOMException

  Specified by:
    `createEntityReference` in interface `Document`
  Parameters:
    `name` - * @return @throws * DOMException
  Throws:
    `DOMException`

### importNode

    public Node importNode(Node importedNode,
                           boolean deep)
                    throws DOMException

  Specified by:
    `importNode` in interface `Document`
  Throws:
    `DOMException`

### createElementNS

    public Element createElementNS(String namespaceURI,
                                   String qualifiedName)
                            throws DOMException

  Return SOAPElements (what if they want SOAPEnvelope or Header/Body?) * * @param namespaceURI * @param qualifiedName * @return @throws * DOMException

  Specified by:
    `createElementNS` in interface `Document`
  Throws:
    `DOMException`

### createAttributeNS

    public Attr createAttributeNS(String namespaceURI,
                                  String qualifiedName)
                           throws DOMException

  Attribute is not particularly dealt with in SAAJ.

  Specified by:
    `createAttributeNS` in interface `Document`
  Throws:
    `DOMException`

### getElementsByTagNameNS

    public NodeList getElementsByTagNameNS(String namespaceURI,
                                           String localName)

  search the SOAPPart in order of SOAPHeader and SOAPBody for the * requested Element name

  Specified by:
    `getElementsByTagNameNS` in interface `Document`

### getElementsByTagName

    public NodeList getElementsByTagName(String localName)

  search the SOAPPart in order of SOAPHeader and SOAPBody for the * requested Element name

  Specified by:
    `getElementsByTagName` in interface `Document`

### getElementById

    public Element getElementById(String elementId)

  Returns the `Element` whose `ID` is given by * `elementId`. If no such element exists, returns `null`. * Behavior is not defined if more than one element has this `ID`. * The DOM implementation must have information that says which attributes * are of type ID. Attributes with the name "ID" are not of type ID unless * so defined. Implementations that do not know whether attributes are of * type ID or not are expected to return `null`. * * @param elementId The unique `id` value for an element. * @return The matching element. * @since DOM Level 2

  Specified by:
    `getElementById` in interface `Document`

### getNodeName

    public String getNodeName()

  Node Implementation

  Specified by:
    `getNodeName` in interface `Node`

### getNodeValue

    public String getNodeValue()
                        throws DOMException

  Specified by:
    `getNodeValue` in interface `Node`
  Throws:
    `DOMException`

### setNodeValue

    public void setNodeValue(String nodeValue)
                      throws DOMException

  Specified by:
    `setNodeValue` in interface `Node`
  Throws:
    `DOMException`

### getNodeType

    public short getNodeType()

  override it in sub-classes * * @return

  Specified by:
    `getNodeType` in interface `Node`

### getParentNode

    public Node getParentNode()

  Specified by:
    `getParentNode` in interface `Node`

### getChildNodes

    public NodeList getChildNodes()

  Specified by:
    `getChildNodes` in interface `Node`

### getFirstChild

    public Node getFirstChild()

  Do we have to count the Attributes as node ???? * * @return

  Specified by:
    `getFirstChild` in interface `Node`

### getLastChild

    public Node getLastChild()

  Specified by:
    `getLastChild` in interface `Node`
  Returns:

### getPreviousSibling

    public Node getPreviousSibling()

  Specified by:
    `getPreviousSibling` in interface `Node`

### getNextSibling

    public Node getNextSibling()

  Specified by:
    `getNextSibling` in interface `Node`

### getAttributes

    public NamedNodeMap getAttributes()

  Specified by:
    `getAttributes` in interface `Node`

### getOwnerDocument

    public Document getOwnerDocument()

  we have to have a link to them...

  Specified by:
    `getOwnerDocument` in interface `Node`

### insertBefore

    public Node insertBefore(Node newChild,
                             Node refChild)
                      throws DOMException

  Specified by:
    `insertBefore` in interface `Node`
  Throws:
    `DOMException`

### replaceChild

    public Node replaceChild(Node newChild,
                             Node oldChild)
                      throws DOMException

  Specified by:
    `replaceChild` in interface `Node`
  Throws:
    `DOMException`

### removeChild

    public Node removeChild(Node oldChild)
                     throws DOMException

  Specified by:
    `removeChild` in interface `Node`
  Throws:
    `DOMException`

### appendChild

    public Node appendChild(Node newChild)
                     throws DOMException

  Specified by:
    `appendChild` in interface `Node`
  Throws:
    `DOMException`

### hasChildNodes

    public boolean hasChildNodes()

  Specified by:
    `hasChildNodes` in interface `Node`

### cloneNode

    public Node cloneNode(boolean deep)

  [todo] Study it more.... to implement the deep mode correctly.

  Specified by:
    `cloneNode` in interface `Node`

### normalize

    public void normalize()

  [todo] is it OK to simply call the superclass?

  Specified by:
    `normalize` in interface `Node`

### isSupported

    public boolean isSupported(String feature,
                               String version)

  Specified by:
    `isSupported` in interface `Node`

### getPrefix

    public String getPrefix()

  Specified by:
    `getPrefix` in interface `Node`

### setPrefix

    public void setPrefix(String prefix)

  Specified by:
    `setPrefix` in interface `Node`

### getNamespaceURI

    public String getNamespaceURI()

  Specified by:
    `getNamespaceURI` in interface `Node`

### setNamespaceURI

    public void setNamespaceURI(String nsURI)

### getLocalName

    public String getLocalName()

  Specified by:
    `getLocalName` in interface `Node`

### hasAttributes

    public boolean hasAttributes()

  Specified by:
    `hasAttributes` in interface `Node`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002 JBoss Group, LLC. All Rights Reserved.