content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  /*
   * Copyright 1999-2004 The Apache Software Foundation.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /*
   * $Id: DOM2DTMdefaultNamespaceDeclarationNode.java,v 1.2.4.1 2005/09/15 08:15:11 suresh_emailid Exp $
   */
  
  package jaxp.sun.org.apache.xml.internal.dtm.ref.dom2dtm;
  
  import jaxp.sun.org.apache.xml.internal.dtm.DTMException;
  
  import org.w3c.dom.Attr;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.w3c.dom.TypeInfo;
  import org.w3c.dom.UserDataHandler;
  import org.w3c.dom.DOMException;
  
  /** This is a kluge to let us shove a declaration for xml: into the
   * DOM2DTM model.  Basically, it creates a proxy node in DOM space to
   * carry the additional information. This is _NOT_ a full DOM
   * implementation, and shouldn't be one since it sits alongside the
   * DOM rather than becoming part of the DOM model.
   *
   * (This used to be an internal class within DOM2DTM. Moved out because
   * I need to perform an instanceof operation on it to support a temporary
   * workaround in DTMManagerDefault.)
   *
   * %REVIEW% What if the DOM2DTM was built around a DocumentFragment and
   * there isn't a single root element? I think this fails that case...
   *
   * %REVIEW% An alternative solution would be to create the node _only_
   * in DTM space, but given how DOM2DTM is currently written I think
   * this is simplest.
   * */
  public class DOM2DTMdefaultNamespaceDeclarationNode implements Attr,TypeInfo
  {
    final String NOT_SUPPORTED_ERR="Unsupported operation on pseudonode";
  
    Element pseudoparent;
    String prefix,uri,nodename;
    int handle;
    DOM2DTMdefaultNamespaceDeclarationNode(Element pseudoparent,String prefix,String uri,int handle)
    {
      this.pseudoparent=pseudoparent;
      this.prefix=prefix;
      this.uri=uri;
      this.handle=handle;
      this.nodename="xmlns:"+prefix;
    }
    public String getNodeName() {return nodename;}
    public String getName() {return nodename;}
    public String getNamespaceURI() {return "http://www.w3.org/2000/xmlns/";}
    public String getPrefix() {return prefix;}
    public String getLocalName() {return prefix;}
    public String getNodeValue() {return uri;}
    public String getValue() {return uri;}
    public Element getOwnerElement() {return pseudoparent;}
  
    public boolean isSupported(String feature, String version) {return false;}
    public boolean hasChildNodes() {return false;}
    public boolean hasAttributes() {return false;}
    public Node getParentNode() {return null;}
    public Node getFirstChild() {return null;}
    public Node getLastChild() {return null;}
    public Node getPreviousSibling() {return null;}
    public Node getNextSibling() {return null;}
    public boolean getSpecified() {return false;}
    public void normalize() {return;}
    public NodeList getChildNodes() {return null;}
    public NamedNodeMap getAttributes() {return null;}
    public short getNodeType() {return Node.ATTRIBUTE_NODE;}
    public void setNodeValue(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public void setValue(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public void setPrefix(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public Node insertBefore(Node a, Node b) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public Node replaceChild(Node a, Node b) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public Node appendChild(Node a) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public Node removeChild(Node a) {throw new DTMException(NOT_SUPPORTED_ERR);}
    public Document getOwnerDocument() {return pseudoparent.getOwnerDocument();}
    public Node cloneNode(boolean deep) {throw new DTMException(NOT_SUPPORTED_ERR);}
  
      /** Non-DOM method, part of the temporary kluge
       * %REVIEW% This would be a pruning problem, but since it will always be
       * added to the root element and we prune on elements, we shouldn't have
       * to worry.
       */
      public int getHandleOfNode()
      {
          return handle;
      }
  
      //RAMESH: PENDING=> Add proper implementation for the below DOM L3 additions
  
      /**
       * @see org.w3c.dom.TypeInfo#getTypeName()
       */
      public String getTypeName() {return null; }
  
      /**
       * @see org.w3c.dom.TypeInfo#getTypeNamespace()
       */
      public String getTypeNamespace() { return null;}
  
      /**
       * @see or.gw3c.dom.TypeInfo#isDerivedFrom(String,String,int)
       */
      public boolean isDerivedFrom( String ns, String localName, int derivationMethod ) {
          return false;
      }
  
      public TypeInfo getSchemaTypeInfo() { return this; }
  
      public boolean isId( ) { return false; }
  
      /**
       * 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 key The key to associate the object to.
       * @param data The object to associate to the given key, or
       *   <code>null</code> to remove any existing association to that key.
       * @param handler The handler to associate to that key, or
       *   <code>null</code>.
       * @return Returns the <code>DOMObject</code> previously associated to
       *   the given key on this node, or <code>null</code> if there was none.
       * @since DOM Level 3
       */
      public Object setUserData(String key,
                                Object data,
                                UserDataHandler handler) {
          return getOwnerDocument().setUserData( key, data, 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 key The key the object is associated to.
       * @return Returns the <code>DOMObject</code> associated to the given key
       *   on this node, or <code>null</code> if there was none.
       * @since DOM Level 3
       */
      public Object getUserData(String key) {
          return getOwnerDocument().getUserData( key);
      }
  
      /**
       *  This method returns a specialized object which implements the
       * specialized APIs of the specified feature and version. The
       * specialized object may also be obtained by using binding-specific
       * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
       * @param feature The name of the feature requested (case-insensitive).
       * @param version  This is the version number of the feature to test. If
       *   the version is <code>null</code> or the empty string, supporting
       *   any version of the feature will cause the method to return an
       *   object that supports at least one version of the feature.
       * @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 Object getFeature(String feature, String version) {
          // we don't have any alternate node, either this node does the job
          // or we don't have anything that does
          return isSupported(feature, version) ? this : null;
      }
  
      /**
       * 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: The two nodes are of the same type.The following string
       * attributes are equal: <code>nodeName</code>, <code>localName</code>,
       * <code>namespaceURI</code>, <code>prefix</code>, <code>nodeValue</code>
       * , <code>baseURI</code>. This is: they are both <code>null</code>, or
       * they have the same length and are character for character identical.
       * 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.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. This is true
       * for <code>Attr</code> nodes as for any other type of node. Note that
       * normalization can affect equality; to avoid this, nodes should be
       * normalized before being compared.
       * <br>For two <code>DocumentType</code> nodes to be equal, the following
       * conditions must also be satisfied: The following string attributes
       * are equal: <code>publicId</code>, <code>systemId</code>,
       * <code>internalSubset</code>.The <code>entities</code>
       * <code>NamedNodeMaps</code> are equal.The <code>notations</code>
       * <code>NamedNodeMaps</code> are equal.
       * <br>On the other hand, the following do not affect equality: the
       * <code>ownerDocument</code> attribute, the <code>specified</code>
       * attribute for <code>Attr</code> nodes, the
       * <code>isWhitespaceInElementContent</code> attribute for
       * <code>Text</code> nodes, as well as any user data or event listeners
       * registered on the nodes.
       * @param arg The node to compare equality with.
       * @param deep If <code>true</code>, recursively compare the subtrees; if
       *   <code>false</code>, compare only the nodes themselves (and its
       *   attributes, if it is an <code>Element</code>).
       * @return If the nodes, and possibly subtrees are equal,
       *   <code>true</code> otherwise <code>false</code>.
       * @since DOM Level 3
       */
      public boolean isEqualNode(Node arg) {
          if (arg == this) {
              return true;
          }
          if (arg.getNodeType() != getNodeType()) {
              return false;
          }
          // in theory nodeName can't be null but better be careful
          // who knows what other implementations may be doing?...
          if (getNodeName() == null) {
              if (arg.getNodeName() != null) {
                  return false;
              }
          }
          else if (!getNodeName().equals(arg.getNodeName())) {
              return false;
          }
  
          if (getLocalName() == null) {
              if (arg.getLocalName() != null) {
                  return false;
              }
          }
          else if (!getLocalName().equals(arg.getLocalName())) {
              return false;
          }
  
          if (getNamespaceURI() == null) {
              if (arg.getNamespaceURI() != null) {
                  return false;
              }
          }
          else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
              return false;
          }
  
          if (getPrefix() == null) {
              if (arg.getPrefix() != null) {
                  return false;
              }
          }
          else if (!getPrefix().equals(arg.getPrefix())) {
              return false;
          }
  
          if (getNodeValue() == null) {
              if (arg.getNodeValue() != null) {
                  return false;
              }
          }
          else if (!getNodeValue().equals(arg.getNodeValue())) {
              return false;
          }
      /*
          if (getBaseURI() == null) {
              if (((NodeImpl) arg).getBaseURI() != null) {
                  return false;
              }
          }
          else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
              return false;
          }
  */
  
               return true;
      }
  
      /**
       * DOM Level 3 - Experimental:
       * Look up the namespace URI associated to the given prefix, starting from this node.
       * Use lookupNamespaceURI(null) to lookup the default namespace
       *
       * @param namespaceURI
       * @return th URI for the namespace
       * @since DOM Level 3
       */
      public String lookupNamespaceURI(String specifiedPrefix) {
          short type = this.getNodeType();
          switch (type) {
          case Node.ELEMENT_NODE : {
  
                  String namespace = this.getNamespaceURI();
                  String prefix = this.getPrefix();
                  if (namespace !=null) {
                      // REVISIT: is it possible that prefix is empty string?
                      if (specifiedPrefix== null && prefix==specifiedPrefix) {
                          // looking for default namespace
                          return namespace;
                      } else if (prefix != null && prefix.equals(specifiedPrefix)) {
                          // non default namespace
                          return namespace;
                      }
                  }
                  if (this.hasAttributes()) {
                      NamedNodeMap map = this.getAttributes();
                      int length = map.getLength();
                      for (int i=0;i<length;i++) {
                          Node attr = map.item(i);
                          String attrPrefix = attr.getPrefix();
                          String value = attr.getNodeValue();
                          namespace = attr.getNamespaceURI();
                          if (namespace !=null && namespace.equals("http://www.w3.org/2000/xmlns/")) {
                              // at this point we are dealing with DOM Level 2 nodes only
                              if (specifiedPrefix == null &&
                                  attr.getNodeName().equals("xmlns")) {
                                  // default namespace
                                  return value;
                              } else if (attrPrefix !=null &&
                                         attrPrefix.equals("xmlns") &&
                                         attr.getLocalName().equals(specifiedPrefix)) {
                   // non default namespace
                                  return value;
                              }
                          }
                      }
                  }
                  /*
                  NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
                  if (ancestor != null) {
                      return ancestor.lookupNamespaceURI(specifiedPrefix);
                  }
                  */
  
                  return null;
  
  
              }
  /*
          case Node.DOCUMENT_NODE : {
                  return((NodeImpl)((Document)this).getDocumentElement()).lookupNamespaceURI(specifiedPrefix) ;
              }
  */
          case Node.ENTITY_NODE :
          case Node.NOTATION_NODE:
          case Node.DOCUMENT_FRAGMENT_NODE:
          case Node.DOCUMENT_TYPE_NODE:
              // type is unknown
              return null;
          case Node.ATTRIBUTE_NODE:{
                  if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
                      return getOwnerElement().lookupNamespaceURI(specifiedPrefix);
  
                  }
                  return null;
              }
          default:{
             /*
                  NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
                  if (ancestor != null) {
                      return ancestor.lookupNamespaceURI(specifiedPrefix);
                  }
               */
                  return null;
              }
  
          }
      }
  
      /**
       *  DOM Level 3: Experimental
       *  This method checks if the specified <code>namespaceURI</code> is the
       *  default namespace or not.
       *  @param namespaceURI The namespace URI to look for.
       *  @return  <code>true</code> if the specified <code>namespaceURI</code>
       *   is the default namespace, <code>false</code> otherwise.
       * @since DOM Level 3
       */
      public boolean isDefaultNamespace(String namespaceURI){
         /*
          // REVISIT: remove casts when DOM L3 becomes REC.
          short type = this.getNodeType();
          switch (type) {
          case Node.ELEMENT_NODE: {
              String namespace = this.getNamespaceURI();
              String prefix = this.getPrefix();
  
              // REVISIT: is it possible that prefix is empty string?
              if (prefix == null || prefix.length() == 0) {
                  if (namespaceURI == null) {
                      return (namespace == namespaceURI);
                  }
                  return namespaceURI.equals(namespace);
              }
              if (this.hasAttributes()) {
                  ElementImpl elem = (ElementImpl)this;
                  NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
                  if (attr != null) {
                      String value = attr.getNodeValue();
                      if (namespaceURI == null) {
                          return (namespace == value);
                      }
                      return namespaceURI.equals(value);
                  }
              }
  
              NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
              if (ancestor != null) {
                  return ancestor.isDefaultNamespace(namespaceURI);
              }
              return false;
          }
          case Node.DOCUMENT_NODE:{
                  return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
              }
  
          case Node.ENTITY_NODE :
            case Node.NOTATION_NODE:
          case Node.DOCUMENT_FRAGMENT_NODE:
          case Node.DOCUMENT_TYPE_NODE:
              // type is unknown
              return false;
          case Node.ATTRIBUTE_NODE:{
                  if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
                      return ownerNode.isDefaultNamespace(namespaceURI);
  
                  }
                  return false;
              }
          default:{
                  NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
                  if (ancestor != null) {
                      return ancestor.isDefaultNamespace(namespaceURI);
                  }
                  return false;
              }
  
          }
  */
          return false;
  
  
      }
  
      /**
       *
       * DOM Level 3 - Experimental:
       * Look up the prefix associated to the given namespace URI, starting from this node.
       *
       * @param namespaceURI
       * @return the prefix for the namespace
       */
      public String lookupPrefix(String namespaceURI){
  
          // REVISIT: When Namespaces 1.1 comes out this may not be true
          // Prefix can't be bound to null namespace
          if (namespaceURI == null) {
              return null;
          }
  
          short type = this.getNodeType();
  
          switch (type) {
  /*
          case Node.ELEMENT_NODE: {
  
                  String namespace = this.getNamespaceURI(); // to flip out children
                  return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
              }
  
          case Node.DOCUMENT_NODE:{
                  return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
              }
  */
          case Node.ENTITY_NODE :
          case Node.NOTATION_NODE:
          case Node.DOCUMENT_FRAGMENT_NODE:
          case Node.DOCUMENT_TYPE_NODE:
              // type is unknown
              return null;
          case Node.ATTRIBUTE_NODE:{
                  if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
                      return getOwnerElement().lookupPrefix(namespaceURI);
  
                  }
                  return null;
              }
          default:{
  /*
                  NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
                  if (ancestor != null) {
                      return ancestor.lookupPrefix(namespaceURI);
                  }
  */
                  return null;
              }
           }
      }
  
      /**
       * 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 interchangably, such that all attributes have the
       * same values and calling the same DOM method on either reference
       * always has exactly the same effect.
       * @param other The node to test against.
       * @return Returns <code>true</code> if the nodes are the same,
       *   <code>false</code> otherwise.
       * @since DOM Level 3
       */
      public boolean isSameNode(Node other) {
          // we do not use any wrapper so the answer is obvious
          return this == other;
      }
  
      /**
       * This attribute returns the text content of this node and its
       * descendants. When it is defined to be null, setting it has no effect.
       * When set, any possible children this node may have are removed and
       * replaced by a single <code>Text</code> node containing the string
       * this attribute is set to. On getting, no serialization is performed,
       * the returned string does not contain any markup. No whitespace
       * normalization is performed, the returned string does not contain the
       * element content whitespaces . 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'>
       * <tr>
       * <th>Node type</th>
       * <th>Content</th>
       * </tr>
       * <tr>
       * <td valign='top' rowspan='1' colspan='1'>
       * ELEMENT_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</td>
       * </tr>
       * <tr>
       * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, 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'>
       * null</td>
       * </tr>
       * </table>
       * @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 <code>DOMString</code> variable on the implementation
       *   platform.
       * @since DOM Level 3
       */
      public void setTextContent(String textContent)
          throws DOMException {
          setNodeValue(textContent);
      }
  
      /**
       * This attribute returns the text content of this node and its
       * descendants. When it is defined to be null, setting it has no effect.
       * When set, any possible children this node may have are removed and
       * replaced by a single <code>Text</code> node containing the string
       * this attribute is set to. On getting, no serialization is performed,
       * the returned string does not contain any markup. No whitespace
       * normalization is performed, the returned string does not contain the
       * element content whitespaces . 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'>
       * <tr>
       * <th>Node type</th>
       * <th>Content</th>
       * </tr>
       * <tr>
       * <td valign='top' rowspan='1' colspan='1'>
       * ELEMENT_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</td>
       * </tr>
       * <tr>
       * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, 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'>
       * null</td>
       * </tr>
       * </table>
       * @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 <code>DOMString</code> variable on the implementation
       *   platform.
       * @since DOM Level 3
       */
      public String getTextContent() throws DOMException {
          return getNodeValue();  // overriden in some subclasses
      }
  
      /**
       * Compares a node with this node with regard to their position in the
       * document.
       * @param other The node to compare against this node.
       * @return Returns how the given node is positioned relatively to this
       *   node.
       * @since DOM Level 3
       */
      public short compareDocumentPosition(Node other) throws DOMException {
          return 0;
      }
  
      /**
       * The absolute base URI of this node or <code>null</code> if undefined.
       * This value is computed according to . However, when the
       * <code>Document</code> supports the feature "HTML" , the base URI is
       * computed using first the value of the href attribute of the HTML BASE
       * element if any, and the value of the <code>documentURI</code>
       * attribute from the <code>Document</code> interface otherwise.
       * <br> When the node is an <code>Element</code>, a <code>Document</code>
       * or a a <code>ProcessingInstruction</code>, this attribute represents
       * the properties [base URI] defined in . When the node is a
       * <code>Notation</code>, an <code>Entity</code>, or an
       * <code>EntityReference</code>, this attribute represents the
       * properties [declaration base URI] in the . How will this be affected
       * by resolution of relative namespace URIs issue?It's not.Should this
       * only be on Document, Element, ProcessingInstruction, Entity, and
       * Notation nodes, according to the infoset? If not, what is it equal to
       * on other nodes? Null? An empty string? I think it should be the
       * parent's.No.Should this be read-only and computed or and actual
       * read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
       * teleconference 30 May 2001).If the base HTML element is not yet
       * attached to a document, does the insert change the Document.baseURI?
       * Yes. (F2F 26 Sep 2001)
       * @since DOM Level 3
       */
      public String getBaseURI() {
          return null;
      }
  }
  