Logo
Distributed Genetic Programming Framework
print print

File org.sfc.xml.dom.DOMDocument.java

Here you can find all the information about the file org.sfc.xml.dom.DOMDocument.java. You may explore it here or download it onto your local disk.
/*
/*
 * Copyright (c) 2005 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-05-16 20:01:54
 * Original Filename: org.sfc.xml.dom.DOMDocument.java
 * Version          : 1.0.2
 * Last modification: 2006-03-07
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.sfc.xml.dom;

import java.io.Serializable;
import java.net.URI;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Attr;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.DOMConfiguration;
import org.w3c.dom.DOMException;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;
import org.w3c.dom.UserDataHandler;

import org.sfc.utils.ICloneable;
import org.sfc.xml.NamespaceManager;
import org.sfc.xml.XML;


/**
 * This class is an encapsulation for dom documents.
 * It extends the typical dom behaviour by hidden
 * namespace caching and support.
 *
 * @author  Thomas Weise
 */

public final  class DOMDocument  extends    NamespaceManager
                                 implements Document,
                                            ICloneable,
                                            Serializable
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
/**
 * The internal dom document.
 */

  private     Document                    m_doc             ;
/**
 * The base url of the document, where it's going to be stored or
 * loaded from.
 */

  private     URI                         m_base_uri        ;




/**
 * Convert a xml document into a dom document with automatically
 * performed namespace management.
 *
 * @param p_source          The source document to delegate to.
 * @param p_base_namespace  The base namespace of the new document.
 * @return  The dom document representation of the xml document.
 */

  public static final DOMDocument get_dom_document(Document p_source,
                                                   String   p_base_namespace)
    {
    if(p_source == null) return null;
    if(p_source instanceof DOMDocument)
      {
      return ((DOMDocument)p_source);
      }

    return new DOMDocument(p_source, p_base_namespace);
    }

/**
 * Create a new XMLDocument that uses the
 * underlying p_source document.
 * @param p_source          The source document to delegate to.
 * @param p_base_namespace  The base namespace of the new document.
 */

  private DOMDocument (final  Document p_source,
                              String   p_base_namespace)
    {
    super();

    String  l_u;

    this.m_doc          = p_source;

    if(p_base_namespace == null)
      {
      p_base_namespace = p_source.getNamespaceURI();
      }

    l_u = p_source.getBaseURI();

    if(l_u != null)
      {
      try
        {
        this.m_base_uri = new URI(l_u);
        }
      catch(Throwable l_t)
        {
        //
        }
      }

    this.set_base_namespace(p_base_namespace);
    this.namespace_check(p_source.getDocumentElement(), true);
    }


/**
 * This method is called whenever a new namespace has been introducted to
 * the namespace manager.
 * @param p_prefix        The prefix assigned to the new namespace.
 * @param p_namespace_uri The new namespace uri.
 */

  @Override
  protected final void  on_new_prefix (final  String  p_prefix,
                                       final  String  p_namespace_uri)
    {
    Element l_el;

    l_el = this.m_doc.getDocumentElement();

    if(l_el != null)
      {
      l_el.setAttribute(XML.XMLNSQ + p_prefix, p_namespace_uri);
      }
    }

/**
 * Create a perfect copy of this dom document.
 * @return  An independent dom document with exactly the same content or
 *          null on error.
 */

  @Override
  public  final Object  clone ()
    {
    DOMDocument             l_dd;
    Document                l_d;
    DocumentBuilderFactory  l_dbf;
    Node                    l_n;

    try
      {
      l_dd = ((DOMDocument)(shallow_clone()));

      l_dbf = DocumentBuilderFactory.newInstance();
      l_dbf.setNamespaceAware(true);
      l_dbf.setIgnoringComments(true);

      l_d = l_dbf.newDocumentBuilder().getDOMImplementation()
                 .createDocument(this.get_base_namespace(), null,
                                 this.m_doc.getDoctype());

      l_n = l_d.importNode(this.m_doc.getDocumentElement(), true);
      l_d.appendChild(l_n);
      l_dd.m_doc        = l_d;
      l_dd.namespace_check(l_n, true);

      return l_dd;
      }
    catch(Throwable l_t)
      {
      return null;
      }
    }


/**
 * Sets the base uri of this document.
 * This is the uri that is going to be used to store and load the
 * document from.
 *
 * @param p_base  The base uri of the document.
 */

  public  final void  set_base_uri  (final  URI  p_base)
    {
    this.m_base_uri = p_base;

    this.m_doc.setDocumentURI((p_base != null) ? p_base.toString() : null);
    }

/**
 * Sets the basic namespace of the document.
 *
 * @param p_base_namespace  The new base namespace of the document.
 */

  @Override
  protected final void  set_base_namespace  (final  String p_base_namespace)
    {
    Element l_el;

    super.set_base_namespace(p_base_namespace);
    l_el                  = this.m_doc.getDocumentElement();

    if(l_el != null)
      {
      if(p_base_namespace != null)
        {
        l_el.setAttribute(XML.XMLNS, this.get_base_namespace());
        }
      else
        {
        l_el.removeAttribute(XML.XMLNS);
        }
      }
    }

/**
 * Returns the base uri of this document.
 * This is the uri that is going to be used to store and load the
 * document from.
 * @return The base uri of the document.
 */

  public  final URI   get_base_uri  ()
    {
    return this.m_base_uri;
    }

/**
 * Perform a recursive namespace check.
 * @param p_child The child element to check.
 * @param p_root  Is the child element the root of the document?
 */

  private final void  namespace_check (final  Node     p_child,
                                       final  boolean  p_root)
    {
    NamedNodeMap    l_nnm;
    NodeList        l_nl;
    int             l_i;
    Node            l_n;
    Attr            l_a;
    String          l_s;

    if((p_child == null) || (!(p_child instanceof Element))) return ;

    if(p_root) this.clear_namespaces();

    l_nnm = p_child.getAttributes();

    if(l_nnm != null)
      {
      for(l_i = (l_nnm.getLength()-1); l_i >= 0; l_i--)
        {
        l_n = l_nnm.item(l_i);

        if(l_n != null)
          {
          if(l_n instanceof Attr)
            {
            l_a = ((Attr)l_n);
            l_s = l_a.getName();

            if(l_s.equals(XML.XMLNS))
              {
              add_namespace(null, l_a.getValue());
              if(!p_root) l_nnm.removeNamedItem(l_s);
              continue;
              }
            if(l_s.startsWith(XML.XMLNSQ))
              {
              add_namespace(l_s.substring(XML.XMLNSQ.length()),
                            l_a.getValue());
              if(!p_root) l_nnm.removeNamedItem(l_s);
              continue;
              }
            }

          if(l_n.getNodeName() != XML.XMLNS) update_prefix(l_n);
          }
        }
      }

    if((l_nl = p_child.getChildNodes()) != null)
      {
      for(l_i = (l_nl.getLength()-1); l_i >= 0; l_i--)
        {
        namespace_check(l_nl.item(l_i), false);
        }
      }

    if(p_root && (this.get_base_namespace() != null) &&
      (p_child instanceof Element))
      {
      ((Element)p_child).setAttribute(XML.XMLNS,
                                      this.get_base_namespace());
      }
    update_prefix(p_child);
    }



/**
 * This small method updates the namespace prefix of a node or attribute.
 * @param p_node  The node to update the prefix of.
 */

  private final void  update_prefix (final  Node p_node)
    {
    String  l_s, l_s2;

    l_s = p_node.getNamespaceURI();
    if(l_s != null)
      {
      l_s = add_namespace(l_s2 = p_node.getPrefix(), l_s);
      if(l_s != l_s2)
        {
        p_node.setPrefix(l_s);
        }
      }
    }








/**
 * This method creates a new subelement that can be appended to the
 * document.
 * @param p_namespace_uri   The namespace of the new element,
 *                          can be null.
 * @param p_name_prefix     The suggested prefix to use for the name.
 *                          Can be null.
 * @param p_name            The name to use.
 * @return     The newly created element.
 */

  public  final Element create_element  (final  String   p_namespace_uri,
                                                String   p_name_prefix,
                                         final  String   p_name)
    {
    p_name_prefix = add_namespace(p_name_prefix, p_namespace_uri);

    return  createElementNS(p_namespace_uri,
                    (p_name_prefix != null) ?
                    (p_name_prefix + XML.NAMESPACE_SEPARATOR + p_name) :
                    p_name);
    }


/**
 * This method sets a value of an attribute of the element p_e.
 * @param p_e               The node to add a new subelement.
 * @param p_namespace_uri   The namespace of the new element.
 *                          Can be null.
 * @param p_name_prefix     The prefix to use for the name.
 *                          Can be null.
 * @param p_name            The name to use.
 * @param p_value           The value of the attribute.
 */

  public  final void  set_attribute   (final  Element  p_e,
                                       final  String   p_namespace_uri,
                                              String   p_name_prefix,
                                       final  String   p_name,
                                       final  String   p_value)
    {
    p_name_prefix = add_namespace(p_name_prefix, p_namespace_uri);
    p_e.setAttributeNS(p_namespace_uri,
                      (p_name_prefix != null) ?
                      (p_name_prefix + XML.NAMESPACE_SEPARATOR + p_name) :
                       p_name,
                       p_value);
    }



/**
 * Removes a node from the document.
 * @param p_node  The node to be removed.
 */

  public  static  final void  remove  (final  Node p_node)
    {
    Node l_n;

    if(p_node != null)
      {
      try
        {
        l_n = p_node.getParentNode();
        if(l_n != null) l_n.removeChild(p_node);
        }
      catch(Throwable l_t)
        {
        //
        }
      }
    }

/**
 * Replaces a node by another.
 * @param p_old   The node to be replace.
 * @param p_new   Its replacement.
 */

  public  static  final void  replace  (final  Node p_old,
                                        final  Node p_new)
    {
    Node l_n;

    if(p_old != null)
      {
      try
        {
        l_n = p_old.getParentNode();
        if(l_n != null) l_n.replaceChild(p_old, p_new);
        }
      catch(Throwable l_t)
        {
        //
        }
      }
    }

// -------------------------------------------------------------
// --------------------- INTERFACE METHODS ---------------------
// -------------------------------------------------------------

/**
 * The Document Type Declaration (see DocumentType)
 * associated with this document. For HTMLDocument documents as well as XML
 * documents without a document type declaration this returns
 * null. The DOM Level 2 does not support editing the
 * Document Type Declaration. docType cannot be altered in
 * any way, including through the use of methods inherited from the
 * Node interface, such as insertNode or
 * removeNode.
 * @return  the document's type
 */

  public final  DocumentType getDoctype()
    {
    return this.m_doc.getDoctype();
    }

/**
 * The DOMImplementation object that handles this document. A
 * DOM application may use objects from multiple implementations.
 * @return  the dom implementation
 */

  public final  DOMImplementation getImplementation()
    {
    return this.m_doc.getImplementation();
    }

/**
 * This is a convenience attribute that allows direct access to the child
 * node that is the root element of the document. For HTMLDocument documents,
 * this is the element with the tagName "HTMLDocument".
 * @return  the documents root element
 */

  public final  Element getDocumentElement()
    {
    return this.m_doc.getDocumentElement();
    }


/**
 * Creates an element of the type specified. Note that the instance
 * returned implements the Element interface, so attributes
 * can be specified directly on the returned object.
 * In addition, if there are known attributes with default values,
 * Attr nodes representing them are automatically created
 * and attached to the element.
 * To create an element with a qualified name and namespace URI, use
 * the createElementNS method.
 * @param p_tag_name The name of the element type to instantiate. For XML,
 *   this is case-sensitive. For HTMLDocument, the tagName
 *   parameter may be provided in any case, but it must be mapped to the
 *   canonical uppercase form by the DOM implementation.
 * @return A new Element object with the
 *   nodeName attribute set to tagName, and
 *   localName, prefix, and
 *   namespaceURI set to null.
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
 *   illegal character.
 */

  public final  Element createElement(final  String p_tag_name)
                               throws DOMException
    {
    return this.m_doc.createElement(p_tag_name);
    }

/**
 * Creates an empty DocumentFragment object.
 * @return A new DocumentFragment.
 */

  public final  DocumentFragment createDocumentFragment()
    {
    return this.m_doc.createDocumentFragment();
    }

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

  public final  Text createTextNode(final  String p_data)
    {
    return this.m_doc.createTextNode(p_data);
    }

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

  public final  Comment createComment(final  String p_data)
    {
    return this.m_doc.createComment(p_data);
    }

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

  public final  CDATASection createCDATASection(final  String p_data)
                                         throws DOMException
    {
    return this.m_doc.createCDATASection(p_data);
    }


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

  public final  ProcessingInstruction createProcessingInstruction (
                                               final  String  p_target,
                                               final  String  p_data)
                                                        throws DOMException
    {
    return this.m_doc.createProcessingInstruction(p_target, p_data);
    }

/**
 * Creates an Attr of the given name. Note that the
 * Attr instance can then be set on an Element
 * using the setAttributeNode method.
 * To create an attribute with a qualified name and namespace URI, use
 * the createAttributeNS method.
 * @param p_name The name of the attribute.
 * @return A new Attr object with the nodeName
 *   attribute set to name, and localName,
 *   prefix, and namespaceURI set to
 *   null. The value of the attribute is the empty string.
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
 *   illegal character.
 */

  public final  Attr createAttribute(final  String p_name)
                              throws DOMException
    {
    return this.m_doc.createAttribute(p_name);
    }

/**
 * Creates an EntityReference object. In addition, if the
 * referenced entity is known, the child list of the
 * EntityReference node is made the same as that of the
 * corresponding Entity node.If any descendant of the
 * Entity node has an unbound namespace prefix, the
 * corresponding descendant of the created EntityReference
 * node is also unbound; (its namespaceURI is
 * null). The DOM Level 2 does not support any mechanism to
 * resolve namespace prefixes.
 * @param p_name The name of the entity to reference.
 * @return The new EntityReference object.
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
 *   illegal character.
 *   NOT_SUPPORTED_ERR: Raised if this document is an HTMLDocument document.
 */

  public final  EntityReference createEntityReference(final  String p_name)
                                               throws DOMException
    {
    return this.m_doc.createEntityReference(p_name);
    }

/**
 * Returns a NodeList of all the Elements with a
 * given tag name in the order in which they are encountered in a
 * preorder traversal of the Document tree.
 * @param p_tagname The name of the tag to match on. The special value "*"
 *   matches all tags.
 * @return A new NodeList object containing all the matched
 *   Elements.
 */

  public final  NodeList getElementsByTagName(final  String p_tagname)
    {
    return this.m_doc.getElementsByTagName(p_tagname);
    }


/**
 * Imports a node from another document to this document. The returned
 * node has no parent; (parentNode is null).
 * The source node is not altered or removed from the original document;
 * this method creates a new copy of the source node.
 *
 * @param p_imported_node The node to import.
 * @param p_deep If true, recursively import the subtree under
 *   the specified node; if false, import only the node
 *   itself, as explained above. This has no effect on Attr
 *   , EntityReference, and Notation nodes.
 * @return The imported node that belongs to this Document.
 * @exception DOMException
 *   NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
 *   supported.
 * @since DOM Level 2
 */

  public final  Node importNode(final  Node     p_imported_node,
                                final  boolean  p_deep)
                           throws DOMException
    {
    Node    l_n;
    l_n = this.m_doc.importNode(p_imported_node, p_deep);
    namespace_check(l_n, false);
    return l_n;
    }


/**
 * Creates an element of the given qualified name and namespace URI.
 * @param p_namespace_uri The namespace URI of the element to create.
 * @param p_qualified_name The qualified name of the element type to
 *   instantiate.
 * @return A new Element object
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified qualified name
 *   contains an illegal character, per the XML 1.0 specification .
 *   NAMESPACE_ERR: Raised if the qualifiedName is
 *   malformed per the Namespaces in XML specification, if the
 *   qualifiedName has a prefix and the
 *   namespaceURI is null, or if the
 *   qualifiedName has a prefix that is "xml" and the
 *   namespaceURI is different from
 *   "http://www.w3.org/XML/1998/namespace".
 *   NOT_SUPPORTED_ERR: Always thrown if the current document does not
 *   support the "XML" feature, since namespaces were
 *   defined by XML.
 * @since DOM Level 2
 */

  public final  Element createElementNS(final  String p_namespace_uri,
                                        final  String p_qualified_name)
                                  throws DOMException
    {
    Element    l_n;
    l_n = this.m_doc.createElementNS(p_namespace_uri, p_qualified_name);
    namespace_check(l_n, false);
    return l_n;
    }


/**
 * Creates an attribute of the given qualified name and namespace URI.
 * @param p_namespace_uri The namespace URI of the attribute to create.
 * @param p_qualified_name The qualified name of the attribute to
 *   instantiate.
 * @return A new Attr object.
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified qualified name
 *   contains an illegal character, per the XML 1.0 specification .
 *   NAMESPACE_ERR: Raised if the qualifiedName is
 *   malformed per the Namespaces in XML specification, if the
 *   qualifiedName has a prefix and the
 *   namespaceURI is null, if the
 *   qualifiedName has a prefix that is "xml" and the
 *   namespaceURI is different from "
 *   http://www.w3.org/XML/1998/namespace", or if the
 *   qualifiedName, or its prefix, is "xmlns" and the
 *   namespaceURI is different from "
 *   http://www.w3.org/2000/xmlns/".
 *   NOT_SUPPORTED_ERR: Always thrown if the current document does not
 *   support the "XML" feature, since namespaces were
 *   defined by XML.
 * @since DOM Level 2
 */

  public final  Attr createAttributeNS(final  String p_namespace_uri,
                                       final  String p_qualified_name)
                                throws DOMException
    {
    Attr l_a;

    l_a = this.m_doc.createAttributeNS(p_namespace_uri, p_qualified_name);
    update_prefix(l_a);
    return l_a;
    }

/**
 * Returns a NodeList of all the Elements with a
 * given local name and namespace URI in the order in which they are
 * encountered in a preorder traversal of the Document tree.
 * @param p_namespace_uri The namespace URI of the elements to match on. The
 *   special value "*" matches all namespaces.
 * @param p_local_name The local name of the elements to match on. The
 *   special value "*" matches all local names.
 * @return A new NodeList object containing all the matched
 *   Elements.
 * @since DOM Level 2
  */

  public final  NodeList getElementsByTagNameNS(
                              final String p_namespace_uri,
                              final String p_local_name)
    {
    return this.m_doc.getElementsByTagNameNS(p_namespace_uri, p_local_name);
    }

/**
 * Returns the Element whose ID is given by
 * p_element_id. 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 p_element_id The unique id value for an element.
 * @return The matching element.
 * @since DOM Level 2
 */

  public final  Element getElementById(final  String p_element_id)
    {
    return this.m_doc.getElementById(p_element_id);
    }

/**
 * @return  The name of this node, depending on its type.
 */

  public  final String  getNodeName()
    {
    return this.m_doc.getNodeName();
    }

/**
 * The value of this node, depending on its type; see the table above.
 * When it is defined to be null, setting it has no effect.
 * @return  the node value
 * @exception DOMException
 *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
 * @exception DOMException
 *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
 *   fit in a DOMString variable on the implementation
 *   platform.
 */

  public  final String  getNodeValue()
                                 throws DOMException
    {
    return this.m_doc.getNodeValue();
    }

/**
 * The value of this node, depending on its type; see the table above.
 * When it is defined to be null, setting it has no effect.
 * @param p_node_value  The new value
 * @exception DOMException
 *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
 * @exception DOMException
 *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
 *   fit in a DOMString variable on the implementation
 *   platform.
 */

  public final  void setNodeValue(final  String p_node_value)
                                 throws DOMException
    {
    this.m_doc.setNodeValue(p_node_value);
    }

/**
 * A code representing the type of the underlying object, as defined above.
 * @return  the node type
 */

  public final  short getNodeType()
    {
    return this.m_doc.getNodeType();
    }

/**
 * The parent of this node. All nodes, except Attr,
 * Document, DocumentFragment,
 * Entity, and Notation may have a parent.
 * However, if a node has just been created and not yet added to the
 * tree, or if it has been removed from the tree, this is
 * null.
 * @return  the parent node
 */

  public final  Node getParentNode()
    {
    return this.m_doc.getParentNode();
    }

/**
 * A NodeList that contains all children of this node. If
 * there are no children, this is a NodeList containing no
 * nodes.
 * @return  the child nodes
 */

  public final  NodeList getChildNodes()
    {
    return this.m_doc.getChildNodes();
    }

/**
 * @return  The first child of this node. If there is no such node,
 *          this returns null.
 */

  public final  Node getFirstChild()
    {
    return this.m_doc.getFirstChild();
    }

/**
 * @return  The node immediately preceding this node.
 *          If there is no such node, this returns null.
 */

  public final  Node getLastChild()
    {
    return this.m_doc.getLastChild();
    }

/**
 * @return  The node immediately preceding this node.
 *          If there is no such node, this returns null.
 */

  public final  Node getPreviousSibling()
    {
    return this.m_doc.getPreviousSibling();
    }

/**
 * @return  The node immediately following this node.
 *          If there is no such node, this returns null.
 */

  public final  Node getNextSibling()
    {
    return this.m_doc.getNextSibling();
    }

/**
 * @return  A NamedNodeMap containing the attributes
 *          of this node (if it is an Element) or
 *          null otherwise.
 */

  public final  NamedNodeMap getAttributes()
    {
    return this.m_doc.getAttributes();
    }

/**
 * The Document object associated with this node. This is
 * also the Document object used to create new nodes. When
 * this node is a Document or a DocumentType
 * which is not used with any Document yet, this is
 * null.
 * @return  the document
 */

  public final  Document getOwnerDocument()
    {
    return this;// this.m_doc.getOwnerDocument();
    }

/**
 * Inserts the node p_new_child before the existing child node
 * refChild. If p_ref_child is null,
 * insert p_new_child at the end of the list of children.
 * If p_new_child is a DocumentFragment object,
 * all of its children are inserted, in the same order, before
 * p_ref_child. If the newChild is already in the
 * tree, it is first removed.
 * @param p_new_child The node to insert.
 * @param p_ref_child The reference node, i.e., the node before which the
 *   new node must be inserted.
 * @return The node being inserted.
 * @exception DOMException
 *   HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
 *   allow children of the type of the newChild node, or if
 *   the node to insert is one of this node's ancestors or this node
 *   itself.
 *   WRONG_DOCUMENT_ERR: Raised if newChild was created
 *   from a different document than the one that created this node.
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
 *   if the parent of the node being inserted is readonly.
 *   NOT_FOUND_ERR: Raised if refChild is not a child of
 *   this node.
 */

  public final  Node insertBefore(final  Node p_new_child,
                                  final  Node p_ref_child)
                           throws DOMException
    {
    Node  l_n;
    l_n = this.m_doc.insertBefore(p_new_child, p_ref_child);
    namespace_check(p_new_child, (l_n == this.m_doc.getDocumentElement()));
    return l_n;
    }

/**
 * Replaces the child node p_old_child with p_new_child
 *  in the list of children, and returns the p_old_child node.
 * If p_new_child is a DocumentFragment object,
 * p_old_child is replaced by all of the
 * DocumentFragment children, which are inserted in the
 * same order. If the p_new_child is already in the tree, it
 * is first removed.
 * @param p_new_child The new node to put in the child list.
 * @param p_old_child The node being replaced in the list.
 * @return The node replaced.
 * @exception DOMException
 *   HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
 *   allow children of the type of the newChild node, or if
 *   the node to put in is one of this node's ancestors or this node
 *   itself.
 *   WRONG_DOCUMENT_ERR: Raised if newChild was created
 *   from a different document than the one that created this node.
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of
 *   the new node is readonly.
 *   NOT_FOUND_ERR: Raised if oldChild is not a child of
 *   this node.
 */

  public final  Node replaceChild(final  Node p_new_child,
                                  final  Node p_old_child)
                             throws DOMException
    {
    Node  l_n;
    l_n = this.m_doc.replaceChild(p_new_child, p_old_child);
    namespace_check(p_new_child, (l_n == this.m_doc.getDocumentElement()));
    return l_n;
    }

/**
 * Removes the child node indicated by p_old_child from the list
 * of children, and returns it.
 * @param p_old_child The node being removed.
 * @return The node removed.
 * @exception DOMException
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
 *   NOT_FOUND_ERR: Raised if p_old_child is not a child of
 *   this node.
 */

  public final  Node removeChild(final  Node p_old_child)
                            throws DOMException
    {
    return this.m_doc.removeChild(p_old_child);
    }

/**
 * Adds the node p_new_child to the end of the list of children
 * of this node. If the p_new_child is already in the tree, it
 * is first removed.
 * @param p_new_child The node to add.If it is a
 *   DocumentFragment object, the entire contents of the
 *   document fragment are moved into the child list of this node
 * @return The node added.
 * @exception DOMException
 *   HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
 *   allow children of the type of the p_new_child node, or if
 *   the node to append is one of this node's ancestors or this node
 *   itself.
 *   WRONG_DOCUMENT_ERR: Raised if p_new_child was created
 *   from a different document than the one that created this node.
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
 *   if the previous parent of the node being inserted is readonly.
 */

  public final  Node appendChild(final  Node p_new_child)
                            throws DOMException
    {
    Node  l_n;
    l_n = this.m_doc.appendChild(p_new_child);
    namespace_check(p_new_child, (l_n == this.m_doc.getDocumentElement()));
    return l_n;
    }

/**
 * Returns whether this node has any children.
 * @return true if this node has any children,
 *   false otherwise.
 */

  public final  boolean hasChildNodes()
    {
    return this.m_doc.hasChildNodes();
    }

/**
 * Returns a duplicate of this node, i.e., serves as a generic copy
 * constructor for nodes. The duplicate node has no parent; (
 * parentNode is null.).
 * Cloning an Element copies all attributes and their
 * values, including those generated by the XML processor to represent
 * defaulted attributes, but this method does not copy any text it
 * contains unless it is a deep clone, since the text is contained in a
 * child Text node. Cloning an Attribute
 * directly, as opposed to be cloned as part of an Element
 * cloning operation, returns a specified attribute (
 * specified is true). Cloning any other type
 * of node simply returns a copy of this node.
 * Note that cloning an immutable subtree results in a mutable copy,
 * but the children of an EntityReference clone are readonly
 * . In addition, clones of unspecified Attr nodes are
 * specified. And, cloning Document,
 * DocumentType, Entity, and
 * Notation nodes is implementation dependent.
 * @param p_deep If true, recursively clone the subtree under
 *   the specified node; if false, clone only the node
 *   itself (and its attributes, if it is an Element).
 * @return The duplicate node.
 */

  public final  Node cloneNode(final  boolean p_deep)
    {
    return new DOMDocument( (Document)(this.m_doc.cloneNode(p_deep)),
                            this.get_base_namespace());
    }

/**
 * Puts all Text nodes in the full depth of the sub-tree
 * underneath this Node, including attribute nodes, into a
 * "normal" form where only structure (e.g., elements, comments,
 * processing instructions, CDATA sections, and entity references)
 * separates Text nodes, i.e., there are neither adjacent
 * Text nodes nor empty Text nodes. This can
 * be used to ensure that the DOM view of a document is the same as if
 * it were saved and re-loaded, and is useful when operations (such as
 * XPointer  lookups) that depend on a particular document tree
 * structure are to be used.In cases where the document contains
 * CDATASections, the normalize operation alone may not be
 * sufficient, since XPointers do not differentiate between
 * Text nodes and CDATASection nodes.
 */

  public final  void normalize()
    {
    this.m_doc.normalize();
    }

/**
 * Tests whether the DOM implementation implements a specific feature and
 * that feature is supported by this node.
 * @param p_feature The name of the feature to org.sfc.ztest. This is the same name
 *   which can be passed to the method hasFeature on
 *   DOMImplementation.
 * @param p_version This is the version number of the feature to org.sfc.ztest. In
 *   Level 2, version 1, this is the string "2.0". If the version is not
 *   specified, supporting any version of the feature will cause the
 *   method to return true.
 * @return Returns true if the specified feature is
 *   supported on this node, false otherwise.
 * @since DOM Level 2
 */

  public final  boolean isSupported(final  String p_feature,
                                    final  String p_version)
    {
    return this.m_doc.isSupported(p_feature, p_version);
    }

/**
 * The namespace URI of this node, or null if it is
 * unspecified.
 * This is not a computed value that is the result of a namespace
 * lookup based on an examination of the namespace declarations in
 * scope. It is merely the namespace URI given at creation time.
 * For nodes of any type other than ELEMENT_NODE and
 * ATTRIBUTE_NODE and nodes created with a DOM Level 1
 * method, such as createElement from the
 * Document interface, this is always null.Per
 * the Namespaces in XML Specification  an attribute does not inherit
 * its namespace from the element it is attached to. If an attribute is
 * not explicitly given a namespace, it simply has no namespace.
 * @return  the namespace uri
 */

  public final  String getNamespaceURI()
    {
    return this.m_doc.getNamespaceURI();
    }

/**
 * The namespace prefix of this node, or null if it is
 * unspecified.
 * Note that setting this attribute, when permitted, changes the
 * nodeName attribute, which holds the qualified name, as
 * well as the tagName and name attributes of
 * the Element and Attr interfaces, when
 * applicable.
 * Note also that changing the prefix of an attribute that is known to
 * have a default value, does not make a new attribute with the default
 * value and the original prefix appear, since the
 * namespaceURI and localName do not change.
 * For nodes of any type other than ELEMENT_NODE and
 * ATTRIBUTE_NODE and nodes created with a DOM Level 1
 * method, such as createElement from the
 * Document interface, this is always null.
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
 *   illegal character, per the XML 1.0 specification .
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
 *   NAMESPACE_ERR: Raised if the specified prefix is
 *   malformed per the Namespaces in XML specification, if the
 *   namespaceURI of this node is null, if the
 *   specified prefix is "xml" and the namespaceURI of this
 *   node is different from "http://www.w3.org/XML/1998/namespace", if
 *   this node is an attribute and the specified prefix is "xmlns" and
 *   the namespaceURI of this node is different from "
 *   http://www.w3.org/2000/xmlns/", or if this node is an attribute and
 *   the qualifiedName of this node is "xmlns" .
 * @return  the namespace prefix
 */

  public final  String getPrefix()
    {
    return this.m_doc.getPrefix();
    }


/**
 * The namespace prefix of this node, or null if it is
 * unspecified.
 * Note that setting this attribute, when permitted, changes the
 * nodeName attribute, which holds the qualified name, as
 * well as the tagName and name attributes of
 * the Element and Attr interfaces, when
 * applicable.
 * Note also that changing the prefix of an attribute that is known to
 * have a default value, does not make a new attribute with the default
 * value and the original prefix appear, since the
 * namespaceURI and localName do not change.
 * For nodes of any type other than ELEMENT_NODE and
 * ATTRIBUTE_NODE and nodes created with a DOM Level 1
 * method, such as createElement from the
 * Document interface, this is always null.
 * @param p_prefix  the new prefix to set
 * @exception DOMException
 *   INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
 *   illegal character, per the XML 1.0 specification .
 *   NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
 *   NAMESPACE_ERR: Raised if the specified prefix is
 *   malformed per the Namespaces in XML specification, if the
 *   namespaceURI of this node is null, if the
 *   specified prefix is "xml" and the namespaceURI of this
 *   node is different from "http://www.w3.org/XML/1998/namespace", if
 *   this node is an attribute and the specified prefix is "xmlns" and
 *   the namespaceURI of this node is different from "
 *   http://www.w3.org/2000/xmlns/", or if this node is an attribute and
 *   the qualifiedName of this node is "xmlns" .
 *
 */

  public final  void setPrefix(final  String p_prefix)
                               throws DOMException
    {
    this.m_doc.setPrefix(p_prefix);
    }

/**
 * Returns the local part of the qualified name of this node.
 * For nodes of any type other than ELEMENT_NODE and
 * ATTRIBUTE_NODE and nodes created with a DOM Level 1
 * method, such as createElement from the
 * Document interface, this is always null.
 * @return  the local name
 */

  public final  String getLocalName()
    {
    return this.m_doc.getLocalName();
    }

/**
 * Returns whether this node (if it is an element) has any attributes.
 * @return true if this node has any attributes,
 *   false otherwise.
 * @since DOM Level 2
 */

  public final  boolean hasAttributes()
    {
    return this.m_doc.hasAttributes();
    }



/**
 * Compares the reference node, i.e. the node on which this method is
 * being called, with a node, i.e. the one passed as a parameter, with
 * regard to their position in the document and according to the
 * document order.
 * @param p_other The node to compare against the reference node.
 * @return Returns how the node is positioned relatively to the reference
 *   node.
 * @exception DOMException
 *   NOT_SUPPORTED_ERR: when the compared nodes are from different DOM
 *   implementations that do not coordinate to return consistent
 *   implementation-specific results.
 * @since DOM Level 3
 */

  public final  short compareDocumentPosition(final  Node p_other)
                                              throws DOMException
    {
    return this.m_doc.compareDocumentPosition(p_other);
    }

/**
 * This attribute returns the text content of this node and its
 * descendants. When it is defined to be <code>null</code>, setting it
 * has no effect. On setting, any possible children this node may have
 * are removed and, if it the new string is not empty or
 * <code>null</code>, replaced by a single <code>Text</code> node
 * containing the string this attribute is set to.
 * <br> On getting, no serialization is performed, the returned string
 * does not contain any markup. No whitespace normalization is performed
 * and the returned string does not contain the white spaces in element
 * content (see the attribute
 * <code>Text.isElementContentWhitespace</code>). Similarly, on setting,
 * no parsing is performed either, the input string is taken as pure
 * textual content.
 * <br>The string returned is made of the text content of this node
 * depending on its type, as defined below:
 * <table border='1' cellpadding='3'>
 * <tr>
 * <th>Node type</th>
 * <th>Content</th>
 * </tr>
 * <tr>
 * <td valign='top' rowspan='1' colspan='1'>
 * ELEMENT_NODE, ATTRIBUTE_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
 * DOCUMENT_FRAGMENT_NODE</td>
 * <td valign='top' rowspan='1' colspan='1'>concatenation of the <code>textContent</code>
 * attribute value of every child node, excluding COMMENT_NODE and
 * PROCESSING_INSTRUCTION_NODE nodes. This is the empty string if the
 * node has no children.</td>
 * </tr>
 * <tr>
 * <td valign='top' rowspan='1' colspan='1'>TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE,
 * PROCESSING_INSTRUCTION_NODE</td>
 * <td valign='top' rowspan='1' colspan='1'><code>nodeValue</code></td>
 * </tr>
 * <tr>
 * <td valign='top' rowspan='1' colspan='1'>DOCUMENT_NODE,
 * DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
 * <td valign='top' rowspan='1' colspan='1'><em>null</em></td>
 * </tr>
 * </table>
 * @exception DOMException
 *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
 *   fit in a <code>DOMString</code> variable on the implementation
 *   platform.
 * @since DOM Level 3
 * @return  The text content.
 */

  public final  String getTextContent()
                                         throws DOMException
    {
    return this.m_doc.getTextContent();
    }

/**
 * Set the text content of this document.
 * @param p_text_content  The new text content.
 * @throws  DOMException  thrown by the underlying implementation if needed
 */

  public final  void setTextContent(final  String p_text_content)
                                         throws DOMException
    {
    this.m_doc.setTextContent(p_text_content);
    }

/**
 * Returns whether this node is the same node as the given one.
 * <br>This method provides a way to determine whether two
 * <code>Node</code> references returned by the implementation reference
 * the same object. When two <code>Node</code> references are references
 * to the same object, even if through a proxy, the references may be
 * used completely interchangeably, such that all attributes have the
 * same values and calling the same DOM method on either reference
 * always has exactly the same effect.
 * @param p_other The node to org.sfc.ztest against.
 * @return Returns <code>true</code> if the nodes are the same,
 *   <code>false</code> otherwise.
 * @since DOM Level 3
 */

  public final  boolean isSameNode(final  Node p_other)
    {
    return (this == p_other) || this.m_doc.isSameNode(p_other);
    }

/**
 * Look up the prefix associated to the given namespace URI, starting from
 * this node. The default namespace declarations are ignored by this
 * method.
 * <br>See  for details on the algorithm used by this method.
 * @param p_namespace_uri The namespace URI to look for.
 * @return Returns an associated namespace prefix if found or
 *   <code>null</code> if none is found. If more than one prefix are
 *   associated to the namespace prefix, the returned namespace prefix
 *   is implementation dependent.
 * @since DOM Level 3
 */

  public final  String lookupPrefix(final  String p_namespace_uri)
    {
    return this.get_prefix(p_namespace_uri);
    }

/**
 * This method checks if the specified <code>namespaceURI</code> is the
 * default namespace or not.
 * @param p_namespace_uri The namespace URI to look for.
 * @return Returns <code>true</code> if the specified
 *   <code>namespaceURI</code> is the default namespace,
 *   <code>false</code> otherwise.
 * @since DOM Level 3
 */

  public final  boolean isDefaultNamespace(final  String p_namespace_uri)
    {
    String  l_s;

    l_s = this.get_base_namespace();
    if( (l_s == null) && (p_namespace_uri == null) ) return true;
    if(l_s != null) return l_s.equals(p_namespace_uri);
    return false;
    }

/**
 * Look up the namespace URI associated to the given prefix, starting from
 * this node.
 * <br>See  for details on the algorithm used by this method.
 * @param p_prefix The prefix to look for. If this parameter is
 *   <code>null</code>, the method will return the default namespace URI
 *   if any.
 * @return Returns the associated namespace URI or <code>null</code> if
 *   none is found.
 * @since DOM Level 3
 */

  public final  String lookupNamespaceURI(final  String p_prefix)
    {
    return this.get_namespace(p_prefix);
    }

/**
 * Tests whether two nodes are equal.
 * <br>This method tests for equality of nodes, not sameness (i.e.,
 * whether the two nodes are references to the same object) which can be
 * tested with <code>Node.isSameNode()</code>. All nodes that are the
 * same will also be equal, though the reverse may not be true.
 * <br>Two nodes are equal if and only if the following conditions are
 * satisfied:
 * <ul>
 * <li>The two nodes are of the same type.
 * </li>
 * <li>The following string
 * attributes are equal: <code>nodeName</code>, <code>localName</code>,
 * <code>namespaceURI</code>, <code>prefix</code>, <code>nodeValue</code>
 * . This is: they are both <code>null</code>, or they have the same
 * length and are character for character identical.
 * </li>
 * <li>The
 * <code>attributes</code> <code>NamedNodeMaps</code> are equal. This
 * is: they are both <code>null</code>, or they have the same length and
 * for each node that exists in one map there is a node that exists in
 * the other map and is equal, although not necessarily at the same
 * index.
 * </li>
 * <li>The <code>childNodes</code> <code>NodeLists</code> are equal.
 * This is: they are both <code>null</code>, or they have the same
 * length and contain equal nodes at the same index. Note that
 * normalization can affect equality; to avoid this, nodes should be
 * normalized before being compared.
 * </li>
 * </ul>
 * <br>For two <code>DocumentType</code> nodes to be equal, the following
 * conditions must also be satisfied:
 * <ul>
 * <li>The following string attributes
 * are equal: <code>publicId</code>, <code>systemId</code>,
 * <code>internalSubset</code>.
 * </li>
 * <li>The <code>entities</code>
 * <code>NamedNodeMaps</code> are equal.
 * </li>
 * <li>The <code>notations</code>
 * <code>NamedNodeMaps</code> are equal.
 * </li>
 * </ul>
 * <br>On the other hand, the following do not affect equality: the
 * <code>ownerDocument</code>, <code>baseURI</code>, and
 * <code>parentNode</code> attributes, the <code>specified</code>
 * attribute for <code>Attr</code> nodes, the <code>schemaTypeInfo</code>
 *  attribute for <code>Attr</code> and <code>Element</code> nodes, the
 * <code>Text.isElementContentWhitespace</code> attribute for
 * <code>Text</code> nodes, as well as any user data or event listeners
 * registered on the nodes.
 * <p ><b>Note:</b>  As a general rule, anything not mentioned in the
 * description above is not significant in consideration of equality
 * checking. Note that future versions of this specification may take
 * into account more attributes and implementations conform to this
 * specification are expected to be updated accordingly.
 * @param p_arg The node to compare equality with.
 * @return Returns <code>true</code> if the nodes are equal,
 *   <code>false</code> otherwise.
 * @since DOM Level 3
 */

  public final  boolean isEqualNode(final  Node p_arg)
    {
    return (this == p_arg) || this.m_doc.isEqualNode(p_arg);
    }

/**
 *  This method returns a specialized object which implements the
 * specialized APIs of the specified feature and version, as specified
 * in . The specialized object may also be obtained by using
 * binding-specific casting methods but is not necessarily expected to,
 * as discussed in . This method also allow the implementation to
 * provide specialized objects which do not support the <code>Node</code>
 *  interface.
 * @param p_feature  The name of the feature requested. Note that any plus
 *   sign "+" prepended to the name of the feature will be ignored since
 *   it is not significant in the context of this method.
 * @param p_version  This is the version number of the feature to org.sfc.ztest.
 * @return  Returns an object which implements the specialized APIs of
 *   the specified feature and version, if any, or <code>null</code> if
 *   there is no object which implements interfaces associated with that
 *   feature. If the <code>DOMObject</code> returned by this method
 *   implements the <code>Node</code> interface, it must delegate to the
 *   primary core <code>Node</code> and not return results inconsistent
 *   with the primary core <code>Node</code> such as attributes,
 *   childNodes, etc.
 * @since DOM Level 3
 */

  public final  Object getFeature(final  String p_feature,
                                  final  String p_version)
    {
    return this.m_doc.getFeature(p_feature, p_version);
    }

/**
 * Associate an object to a key on this node. The object can later be
 * retrieved from this node by calling <code>getUserData</code> with the
 * same key.
 * @param p_key The key to associate the object to.
 * @param p_data The object to associate to the given key, or
 *   <code>null</code> to remove any existing association to that key.
 * @param p_handler The handler to associate to that key, or
 *   <code>null</code>.
 * @return Returns the <code>DOMUserData</code> previously associated to
 *   the given key on this node, or <code>null</code> if there was none.
 * @since DOM Level 3
 */

  public final  Object setUserData( final  String          p_key,
                                    final  Object          p_data,
                                    final  UserDataHandler p_handler)
    {
    return this.m_doc.setUserData(p_key, p_data, p_handler);
    }

/**
 * Retrieves the object associated to a key on a this node. The object
 * must first have been set to this node by calling
 * <code>setUserData</code> with the same key.
 * @param p_key The key the object is associated to.
 * @return Returns the <code>DOMUserData</code> associated to the given
 *   key on this node, or <code>null</code> if there was none.
 * @since DOM Level 3
 */

  public final  Object getUserData(final  String p_key)
    {
    return this.m_doc.getUserData(p_key);
    }


/**
 * An attribute specifying the encoding used for this document at the time
 * of the parsing. This is <code>null</code> when it is not known, such
 * as when the <code>Document</code> was created in memory.
 * @return  The input encoding.
 * @since DOM Level 3
 */

  public final  String getInputEncoding()
    {
    return this.m_doc.getInputEncoding();
    }

/**
 * An attribute specifying, as part of the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML declaration</a>,
 * the encoding of this document. This is <code>null</code> when
 * unspecified or when it is not known, such as when the
 * <code>Document</code> was created in memory.
 * @return  The XML encoding.
 * @since DOM Level 3
 */

  public final  String getXmlEncoding()
    {
    return this.m_doc.getXmlEncoding();
    }

/**
 * An attribute specifying, as part of the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML declaration</a>,
 * whether this document is standalone. This is <code>false</code> when
 * unspecified.
 * <p ><b>Note:</b>  No verification is done on the value when setting
 * this attribute. Applications should use
 * <code>Document.normalizeDocument()</code> with the "validate"
 * parameter to verify if the value matches the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#sec-rmd'>validity
 * constraint for standalone document declaration</a> as defined in
 * [<a href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>].
 * @since DOM Level 3
 * @return  The xml standalone.
 */

  public final  boolean getXmlStandalone()
    {
    return this.m_doc.getXmlStandalone();
    }

/**
 * An attribute specifying, as part of the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML declaration</a>,
 * whether this document is standalone. This is <code>false</code> when
 * unspecified.
 * <p ><b>Note:</b>  No verification is done on the value when setting
 * this attribute. Applications should use
 * <code>Document.normalizeDocument()</code> with the "validate"
 * parameter to verify if the value matches the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#sec-rmd'>validity
 * constraint for standalone document declaration</a> as defined in
 * [<a href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>].
 * @param p_xml_standalone  The standalone property.
 * @exception DOMException
 *    NOT_SUPPORTED_ERR: Raised if this document does not support the
 *   "XML" feature.
 * @since DOM Level 3
 */

  public void setXmlStandalone(final  boolean p_xml_standalone)
                                throws DOMException
    {
    this.m_doc.setXmlStandalone(p_xml_standalone);
    }

/**
 *  An attribute specifying, as part of the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML declaration</a>,
 * the version number of this document. If there is no declaration and if
 * this document supports the "XML" feature, the value is
 * <code>"1.0"</code>. If this document does not support the "XML"
 * feature, the value is always <code>null</code>. Changing this
 * attribute will affect methods that check for invalid characters in
 * XML names. Application should invoke
 * <code>Document.normalizeDocument()</code> in order to check for
 * invalid characters in the <code>Node</code>s that are already part of
 * this <code>Document</code>.
 * <br> DOM applications may use the
 * <code>DOMImplementation.hasFeature(feature, version)</code> method
 * with parameter values "XMLVersion" and "1.0" (respectively) to
 * determine if an implementation supports
 * [<a href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>]. DOM
 * applications may use the same method with parameter values
 * "XMLVersion" and "1.1" (respectively) to determine if an
 * implementation supports
 * [<a href='http://www.w3.org/TR/2004/REC-xml11-20040204/'>XML 1.1</a>].
 * In both
 * cases, in order to support XML, an implementation must also support
 * the "XML" feature defined in this specification. <code>Document</code>
 *  objects supporting a version of the "XMLVersion" feature must not
 * raise a <code>NOT_SUPPORTED_ERR</code> exception for the same version
 * number when using <code>Document.xmlVersion</code>.
 * @since DOM Level 3
 * @return  The xml version.
 */

  public final  String getXmlVersion()
    {
    return this.m_doc.getXmlVersion();
    }

/**
 *  An attribute specifying, as part of the
 * <a href='http://www.w3.org/TR/2004/REC-xml-20040204#NT-XMLDecl'>XML declaration</a>,
 * the version number of this document. If there is no declaration and if
 * this document supports the "XML" feature, the value is
 * <code>"1.0"</code>. If this document does not support the "XML"
 * feature, the value is always <code>null</code>. Changing this
 * attribute will affect methods that check for invalid characters in
 * XML names. Application should invoke
 * <code>Document.normalizeDocument()</code> in order to check for
 * invalid characters in the <code>Node</code>s that are already part of
 * this <code>Document</code>.
 * <br> DOM applications may use the
 * <code>DOMImplementation.hasFeature(feature, version)</code> method
 * with parameter values "XMLVersion" and "1.0" (respectively) to
 * determine if an implementation supports
 * [<a href='http://www.w3.org/TR/2004/REC-xml-20040204'>XML 1.0</a>]. DOM
 * applications may use the same method with parameter values
 * "XMLVersion" and "1.1" (respectively) to determine if an
 * implementation supports
 * [<a href='http://www.w3.org/TR/2004/REC-xml11-20040204/'>XML 1.1</a>].
 * In both
 * cases, in order to support XML, an implementation must also support
 * the "XML" feature defined in this specification. <code>Document</code>
 *  objects supporting a version of the "XMLVersion" feature must not
 * raise a <code>NOT_SUPPORTED_ERR</code> exception for the same version
 * number when using <code>Document.xmlVersion</code>.
 * @param p_xml_version The xml version.
 * @exception DOMException
 *    NOT_SUPPORTED_ERR: Raised if the version is set to a value that is
 *   not supported by this <code>Document</code> or if this document
 *   does not support the "XML" feature.
 * @since DOM Level 3
 */

  public final  void setXmlVersion(final  String p_xml_version)
                                        throws DOMException
    {
    this.m_doc.setXmlVersion(p_xml_version);
    }

/**
 * An attribute specifying whether error checking is enforced or not. When
 * set to <code>false</code>, the implementation is free to not org.sfc.ztest
 * every possible error case normally defined on DOM operations, and not
 * raise any <code>DOMException</code> on DOM operations or report
 * errors while using <code>Document.normalizeDocument()</code>. In case
 * of error, the behavior is undefined. This attribute is
 * <code>true</code> by default.
 * @return  true if strict error checking is on.
 * @since DOM Level 3
 */

  public final  boolean getStrictErrorChecking()
    {
    return this.m_doc.getStrictErrorChecking();
    }

/**
 * An attribute specifying whether error checking is enforced or not. When
 * set to <code>false</code>, the implementation is free to not org.sfc.ztest
 * every possible error case normally defined on DOM operations, and not
 * raise any <code>DOMException</code> on DOM operations or report
 * errors while using <code>Document.normalizeDocument()</code>. In case
 * of error, the behavior is undefined. This attribute is
 * <code>true</code> by default.
 * @param p_strict_error_checking true if strict error checking should be
 *                                turned on, false if it should be turned
 *                                off,
 * @since DOM Level 3
 */

  public final  void setStrictErrorChecking(
                        final  boolean p_strict_error_checking)
    {
    this.m_doc.setStrictErrorChecking(p_strict_error_checking);
    }

/**
 *  The location of the document or <code>null</code> if undefined or if
 * the <code>Document</code> was created using
 * <code>DOMImplementation.createDocument</code>. No lexical checking is
 * performed when setting this attribute; this could result in a
 * <code>null</code> value returned when using <code>Node.baseURI</code>
 * .
 * <br> Beware that when the <code>Document</code> supports the feature
 * "HTMLDocument" [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTMLDocument-20030109'>
 * DOM Level 2 HTMLDocument</a>]
 * , the href attribute of the HTMLDocument BASE element takes precedence over
 * this attribute when computing <code>Node.baseURI</code>.
 * @return  The document's uri.
 * @since DOM Level 3
 */

  public final  String getDocumentURI()
    {
    URI l_u;

    l_u = this.m_base_uri;
    return (l_u != null) ? l_u.toString() : null;
    }

/**
 *  The location of the document or <code>null</code> if undefined or if
 * the <code>Document</code> was created using
 * <code>DOMImplementation.createDocument</code>. No lexical checking is
 * performed when setting this attribute; this could result in a
 * <code>null</code> value returned when using <code>Node.baseURI</code>
 * .
 * <br> Beware that when the <code>Document</code> supports the feature
 * "HTMLDocument"
 * [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTMLDocument-20030109'>DOM Level 2 HTMLDocument</a>]
 * , the href attribute of the HTMLDocument BASE element takes precedence over
 * this attribute when computing <code>Node.baseURI</code>.
 * @param p_document_uri  The new document base uri.
 * @since DOM Level 3
 */

  public final  void setDocumentURI(final  String p_document_uri)
    {
    if(p_document_uri == null) this.set_base_uri(null);

    try
      {
      this.set_base_uri(new URI(p_document_uri));
      }
    catch(Throwable l_t)
      {
      this.set_base_uri(null);
      }
    }

/**
 * Attempts to adopt a node from another document to this document. If
 * supported, it changes the <code>ownerDocument</code> of the source
 * node, its children, as well as the attached attribute nodes if there
 * are any. If the source node has a parent it is first removed from the
 * child list of its parent. This effectively allows moving a subtree
 * from one document to another (unlike <code>importNode()</code> which
 * create a copy of the source node instead of moving it). When it
 * fails, applications should use <code>Document.importNode()</code>
 * instead. Note that if the adopted node is already part of this
 * document (i.e. the source and target document are the same), this
 * method still has the effect of removing the source node from the
 * child list of its parent, if any. 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
 * adopted <code>Attr</code>. The descendants of the source
 * <code>Attr</code> are recursively adopted.</dd>
 * <dt>DOCUMENT_FRAGMENT_NODE</dt>
 * <dd>The
 * descendants of the source node are recursively adopted.</dd>
 * <dt>DOCUMENT_NODE</dt>
 * <dd>
 * <code>Document</code> nodes cannot be adopted.</dd>
 * <dt>DOCUMENT_TYPE_NODE</dt>
 * <dd>
 * <code>DocumentType</code> nodes cannot be adopted.</dd>
 * <dt>ELEMENT_NODE</dt>
 * <dd><em>Specified</em> attribute nodes of the source element are adopted. Default attributes
 * are discarded, though if the document being adopted into defines
 * default attributes for this element name, those are assigned. The
 * descendants of the source element are recursively adopted.</dd>
 * <dt>ENTITY_NODE</dt>
 * <dd>
 * <code>Entity</code> nodes cannot be adopted.</dd>
 * <dt>ENTITY_REFERENCE_NODE</dt>
 * <dd>Only
 * the <code>EntityReference</code> node itself is adopted, the
 * descendants are discarded, 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 cannot be
 * adopted.</dd>
 * <dt>PROCESSING_INSTRUCTION_NODE, TEXT_NODE, CDATA_SECTION_NODE,
 * COMMENT_NODE</dt>
 * <dd>These nodes can all be adopted. No specifics.</dd>
 * </dl>
 * <p ><b>Note:</b>  Since it does not create new nodes unlike the
 * <code>Document.importNode()</code> method, this method does not raise
 * an <code>INVALID_CHARACTER_ERR</code> exception, and applications
 * should use the <code>Document.normalizeDocument()</code> method to
 * check if an imported name is not an XML name according to the XML
 * version in use.
 * @param p_source The node to move into this document.
 * @return The adopted node, or <code>null</code> if this operation
 *   fails, such as when the source node comes from a different
 *   implementation.
 * @exception DOMException
 *   NOT_SUPPORTED_ERR: Raised if the source node is of type
 *   <code>DOCUMENT</code>, <code>DOCUMENT_TYPE</code>.
 *   <br>NO_MODIFICATION_ALLOWED_ERR: Raised when the source node is
 *   readonly.
 * @since DOM Level 3
 */

  public final  Node adoptNode(final  Node p_source)
                          throws DOMException
    {
    Node  l_n;

    l_n = this.m_doc.adoptNode(p_source);
    namespace_check(l_n, false);
    return l_n;
    }

/**
 * The configuration used when <code>Document.normalizeDocument()</code>
 * is invoked.
 * @return  The dom configuration of this document.
 * @since DOM Level 3
 */

  public final  DOMConfiguration getDomConfig()
    {
    return this.m_doc.getDomConfig();
    }

/**
 *  This method acts as if the document was going through a save and load
 * cycle, putting the document in a "normal" form. As a consequence,
 * this method updates the replacement tree of
 * <code>EntityReference</code> nodes and normalizes <code>Text</code>
 * nodes, as defined in the method <code>Node.normalize()</code>.
 * <br> Otherwise, the actual result depends on the features being set on
 * the <code>Document.domConfig</code> object and governing what
 * operations actually take place. Noticeably this method could also
 * make the document namespace well-formed according to the algorithm
 * described in , check the character normalization, remove the
 * <code>CDATASection</code> nodes, etc. See
 * <code>DOMConfiguration</code> for details.
 * <pre>// Keep in the document
 * the information defined // in the XML Information Set (Java example)
 * DOMConfiguration docConfig = myDocument.getDomConfig();
 * docConfig.setParameter("infoset", Boolean.TRUE);
 * myDocument.normalizeDocument();</pre>
 *
 * <br>Mutation events, when supported, are generated to reflect the
 * changes occurring on the document.
 * <br> If errors occur during the invocation of this method, such as an
 * attempt to update a read-only node or a <code>Node.nodeName</code>
 * contains an invalid character according to the XML version in use,
 * errors or warnings (<code>DOMError.SEVERITY_ERROR</code> or
 * <code>DOMError.SEVERITY_WARNING</code>) will be reported using the
 * <code>DOMErrorHandler</code> object associated with the "error-handler
 * " parameter. Note this method might also report fatal errors (
 * <code>DOMError.SEVERITY_FATAL_ERROR</code>) if an implementation
 * cannot recover from an error.
 * @since DOM Level 3
 */

  public final  void normalizeDocument()
    {
    this.m_doc.normalizeDocument();
    }

/**
 * Rename an existing node of type <code>ELEMENT_NODE</code> or
 * <code>ATTRIBUTE_NODE</code>.
 * <br>When possible this simply changes the name of the given node,
 * otherwise this creates a new node with the specified name and
 * replaces the existing node with the new node as described below.
 * <br>If simply changing the name of the given node is not possible, the
 * following operations are performed: a new node is created, any
 * registered event listener is registered on the new node, any user
 * data attached to the old node is removed from that node, the old node
 * is removed from its parent if it has one, the children are moved to
 * the new node, if the renamed node is an <code>Element</code> its
 * attributes are moved to the new node, the new node is inserted at the
 * position the old node used to have in its parent's child nodes list
 * if it has one, the user data that was attached to the old node is
 * attached to the new node.
 * <br>When the node being renamed is an <code>Element</code> only the
 * specified attributes are moved, default attributes originated from
 * the DTD are updated according to the new element name. In addition,
 * the implementation may update default attributes from other schemas.
 * Applications should use <code>Document.normalizeDocument()</code> to
 * guarantee these attributes are up-to-date.
 * <br>When the node being renamed is an <code>Attr</code> that is
 * attached to an <code>Element</code>, the node is first removed from
 * the <code>Element</code> attributes map. Then, once renamed, either
 * by modifying the existing node or creating a new one as described
 * above, it is put back.
 * <br>In addition,
 * <ul>
 * <li> a user data event <code>NODE_RENAMED</code> is fired,
 * </li>
 * <li>
 * when the implementation supports the feature "MutationNameEvents",
 * each mutation operation involved in this method fires the appropriate
 * event, and in the end the event {
 * <code>http://www.w3.org/2001/xml-events</code>,
 * <code>DOMElementNameChanged</code>} or {
 * <code>http://www.w3.org/2001/xml-events</code>,
 * <code>DOMAttributeNameChanged</code>} is fired.
 * </li>
 * </ul>
 * @param p_n The node to rename.
 * @param p_namespace_uri The new namespace URI.
 * @param p_qualified_name The new qualified name.
 * @return The renamed node. This is either the specified node or the new
 *   node that was created to replace the specified node.
 * @exception DOMException
 *   NOT_SUPPORTED_ERR: Raised when the type of the specified node is
 *   neither <code>ELEMENT_NODE</code> nor <code>ATTRIBUTE_NODE</code>,
 *   or if the implementation does not support the renaming of the
 *   document element.
 *   <br>INVALID_CHARACTER_ERR: Raised if the new qualified name is not an
 *   XML name according to the XML version in use specified in the
 *   <code>Document.xmlVersion</code> attribute.
 *   <br>WRONG_DOCUMENT_ERR: Raised when the specified node was created
 *   from a different document than this document.
 *   <br>NAMESPACE_ERR: Raised if the <code>qualifiedName</code> is a
 *   malformed qualified name, 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
 * "<a href='http://www.w3.org/XML/1998/namespace'>
 *   http://www.w3.org/XML/1998/namespace</a>"
 * [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML Namespaces</a>]
 *   . Also raised, when the node being renamed is an attribute, if the
 *   <code>qualifiedName</code>, or its prefix, is "xmlns" and the
 *   <code>namespaceURI</code> is different from
 * "<a href='http://www.w3.org/2000/xmlns/'>http://www.w3.org/2000/xmlns/</a>".
 * @since DOM Level 3
 */

  public final  Node renameNode(final  Node   p_n,
                                final  String p_namespace_uri,
                                final  String p_qualified_name)
                           throws DOMException
    {
    Node  l_n;

    l_n = this.m_doc.renameNode(p_n, p_namespace_uri, p_qualified_name);
    this.namespace_check(l_n, (l_n == this.m_doc.getDocumentElement()));
    return l_n;
    }


/**
 * The absolute base URI of this node or <code>null</code> if the
 * implementation wasn't able to obtain an absolute URI. This value is
 * computed as described in . However, when the <code>Document</code>
 * supports the feature "HTMLDocument" [<a href='http://www.w3.org/TR/2003/REC-DOM-Level-2-HTMLDocument-20030109'>DOM Level 2 HTMLDocument</a>]
 * , the base URI is computed using first the value of the href
 * attribute of the HTMLDocument BASE element if any, and the value of the
 * <code>documentURI</code> attribute from the <code>Document</code>
 * interface otherwise.
 * @return  The node's base uri.
 * @since DOM Level 3
 */

  public final  String getBaseURI()
    {
    return this.getDocumentURI();
    }
  }

File Information:

file name:DOMDocument.java
package:org.sfc.xml.dom
qualified name:org.sfc.xml.dom.DOMDocument.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/xml/dom/DOMDocument.java
size:72.551 KB (74293 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-03-07 04:20:28 GMT+0000
last access: 2018-04-21 04:06:39 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-21 04:06:40 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo