| /* |
| * 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: DTMNodeProxy.java,v |
| */ |
| package com.sun.org.apache.xml.internal.dtm.ref; |
| |
| import java.util.Vector; |
| |
| import com.sun.org.apache.xml.internal.dtm.DTM; |
| import com.sun.org.apache.xml.internal.dtm.DTMDOMException; |
| import com.sun.org.apache.xpath.internal.NodeSet; |
| import java.util.Objects; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.Comment; |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.DOMImplementation; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.DocumentType; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.EntityReference; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.ProcessingInstruction; |
| import org.w3c.dom.Text; |
| |
| import org.w3c.dom.UserDataHandler; |
| import org.w3c.dom.DOMConfiguration; |
| import org.w3c.dom.TypeInfo; |
| |
| /** |
| * <code>DTMNodeProxy</code> presents a DOM Node API front-end to the DTM model. |
| * <p> |
| * It does _not_ attempt to address the "node identity" question; no effort |
| * is made to prevent the creation of multiple proxies referring to a single |
| * DTM node. Users can create a mechanism for managing this, or relinquish the |
| * use of "==" and use the .sameNodeAs() mechanism, which is under |
| * consideration for future versions of the DOM. |
| * <p> |
| * DTMNodeProxy may be subclassed further to present specific DOM node types. |
| * |
| * @see org.w3c.dom |
| */ |
| public class DTMNodeProxy |
| implements Node, Document, Text, Element, Attr, |
| ProcessingInstruction, Comment, DocumentFragment |
| { |
| |
| /** The DTM for this node. */ |
| public DTM dtm; |
| |
| /** The DTM node handle. */ |
| int node; |
| |
| /** The return value as Empty String. */ |
| private static final String EMPTYSTRING = ""; |
| |
| /** The DOMImplementation object */ |
| static final DOMImplementation implementation=new DTMNodeProxyImplementation(); |
| |
| /** |
| * Create a DTMNodeProxy Node representing a specific Node in a DTM |
| * |
| * @param dtm The DTM Reference, must be non-null. |
| * @param node The DTM node handle. |
| */ |
| public DTMNodeProxy(DTM dtm, int node) |
| { |
| this.dtm = dtm; |
| this.node = node; |
| } |
| |
| /** |
| * NON-DOM: Return the DTM model |
| * |
| * @return The DTM that this proxy is a representative for. |
| */ |
| public final DTM getDTM() |
| { |
| return dtm; |
| } |
| |
| /** |
| * NON-DOM: Return the DTM node number |
| * |
| * @return The DTM node handle. |
| */ |
| public final int getDTMNodeNumber() |
| { |
| return node; |
| } |
| |
| /** |
| * Test for equality based on node number. |
| * |
| * @param node A DTM node proxy reference. |
| * |
| * @return true if the given node has the same handle as this node. |
| */ |
| public final boolean equals(Node node) |
| { |
| |
| try |
| { |
| DTMNodeProxy dtmp = (DTMNodeProxy) node; |
| |
| // return (dtmp.node == this.node); |
| // Patch attributed to Gary L Peskin <garyp@firstech.com> |
| return (dtmp.node == this.node) && (dtmp.dtm == this.dtm); |
| } |
| catch (ClassCastException cce) |
| { |
| return false; |
| } |
| } |
| |
| /** |
| * Test for equality based on node number. |
| * |
| * @param node A DTM node proxy reference. |
| * |
| * @return true if the given node has the same handle as this node. |
| */ |
| @Override |
| public final boolean equals(Object node) |
| { |
| // DTMNodeProxy dtmp = (DTMNodeProxy)node; |
| // return (dtmp.node == this.node); |
| // Patch attributed to Gary L Peskin <garyp@firstech.com> |
| return node instanceof Node && equals((Node) node); |
| } |
| |
| @Override |
| public int hashCode() { |
| int hash = 7; |
| hash = 29 * hash + Objects.hashCode(this.dtm); |
| hash = 29 * hash + this.node; |
| return hash; |
| } |
| |
| /** |
| * FUTURE DOM: Test node identity, in lieu of Node==Node |
| * |
| * @param other |
| * |
| * @return true if the given node has the same handle as this node. |
| */ |
| public final boolean sameNodeAs(Node other) |
| { |
| |
| if (!(other instanceof DTMNodeProxy)) |
| return false; |
| |
| DTMNodeProxy that = (DTMNodeProxy) other; |
| |
| return this.dtm == that.dtm && this.node == that.node; |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final String getNodeName() |
| { |
| return dtm.getNodeName(node); |
| } |
| |
| /** |
| * A PI's "target" states what processor channel the PI's data |
| * should be directed to. It is defined differently in HTML and XML. |
| * <p> |
| * In XML, a PI's "target" is the first (whitespace-delimited) token |
| * following the "<?" token that begins the PI. |
| * <p> |
| * In HTML, target is always null. |
| * <p> |
| * Note that getNodeName is aliased to getTarget. |
| * |
| * |
| */ |
| @Override |
| public final String getTarget() |
| { |
| return dtm.getNodeName(node); |
| } // getTarget():String |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node as of DOM Level 2 |
| */ |
| @Override |
| public final String getLocalName() |
| { |
| return dtm.getLocalName(node); |
| } |
| |
| /** |
| * @return The prefix for this node. |
| * @see org.w3c.dom.Node as of DOM Level 2 |
| */ |
| @Override |
| public final String getPrefix() |
| { |
| return dtm.getPrefix(node); |
| } |
| |
| /** |
| * |
| * @param prefix |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node as of DOM Level 2 -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final void setPrefix(String prefix) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node as of DOM Level 2 |
| */ |
| @Override |
| public final String getNamespaceURI() |
| { |
| return dtm.getNamespaceURI(node); |
| } |
| |
| /** Ask whether we support a given DOM feature. |
| * In fact, we do not _fully_ support any DOM feature -- we're a |
| * read-only subset -- so arguably we should always return false. |
| * Or we could say that we support DOM Core Level 2 but all nodes |
| * are read-only. Unclear which answer is least misleading. |
| * |
| * NON-DOM method. This was present in early drafts of DOM Level 2, |
| * but was renamed isSupported. It's present here only because it's |
| * cheap, harmless, and might help some poor fool who is still trying |
| * to use an early Working Draft of the DOM. |
| * |
| * @param feature |
| * @param version |
| * |
| * @return false |
| */ |
| public final boolean supports(String feature, String version) |
| { |
| return implementation.hasFeature(feature,version); |
| //throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** Ask whether we support a given DOM feature. |
| * In fact, we do not _fully_ support any DOM feature -- we're a |
| * read-only subset -- so arguably we should always return false. |
| * |
| * @param feature |
| * @param version |
| * |
| * @return false |
| * @see org.w3c.dom.Node as of DOM Level 2 |
| */ |
| @Override |
| public final boolean isSupported(String feature, String version) |
| { |
| return implementation.hasFeature(feature,version); |
| // throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final String getNodeValue() throws DOMException |
| { |
| return dtm.getNodeValue(node); |
| } |
| |
| /** |
| * @return The string value of the node |
| * |
| * @throws DOMException |
| */ |
| public final String getStringValue() throws DOMException |
| { |
| return dtm.getStringValue(node).toString(); |
| } |
| |
| /** |
| * |
| * @param nodeValue |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final void setNodeValue(String nodeValue) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final short getNodeType() |
| { |
| return (short) dtm.getNodeType(node); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Node getParentNode() |
| { |
| |
| if (getNodeType() == Node.ATTRIBUTE_NODE) |
| return null; |
| |
| int newnode = dtm.getParent(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| public final Node getOwnerNode() |
| { |
| |
| int newnode = dtm.getParent(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final NodeList getChildNodes() |
| { |
| |
| // Annoyingly, AxisIterators do not currently implement DTMIterator, so |
| // we can't just wap DTMNodeList around an Axis.CHILD iterator. |
| // Instead, we've created a special-case operating mode for that object. |
| return new DTMChildIterNodeList(dtm,node); |
| |
| // throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Node getFirstChild() |
| { |
| |
| int newnode = dtm.getFirstChild(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Node getLastChild() |
| { |
| |
| int newnode = dtm.getLastChild(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Node getPreviousSibling() |
| { |
| |
| int newnode = dtm.getPreviousSibling(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Node getNextSibling() |
| { |
| |
| // Attr's Next is defined at DTM level, but not at DOM level. |
| if (dtm.getNodeType(node) == Node.ATTRIBUTE_NODE) |
| return null; |
| |
| int newnode = dtm.getNextSibling(node); |
| |
| return (newnode == DTM.NULL) ? null : dtm.getNode(newnode); |
| } |
| |
| // DTMNamedNodeMap m_attrs; |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final NamedNodeMap getAttributes() |
| { |
| |
| return new DTMNamedNodeMap(dtm, node); |
| } |
| |
| /** |
| * Method hasAttribute |
| * |
| * |
| * @param name |
| * |
| */ |
| @Override |
| public boolean hasAttribute(String name) |
| { |
| return DTM.NULL != dtm.getAttributeNode(node,null,name); |
| } |
| |
| /** |
| * Method hasAttributeNS |
| * |
| * |
| * @param namespaceURI |
| * @param localName |
| * |
| * |
| */ |
| @Override |
| public boolean hasAttributeNS(String namespaceURI, String localName) |
| { |
| return DTM.NULL != dtm.getAttributeNode(node,namespaceURI,localName); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final Document getOwnerDocument() |
| { |
| // Note that this uses the DOM-compatable version of the call |
| return (Document)(dtm.getNode(dtm.getOwnerDocument(node))); |
| } |
| |
| /** |
| * |
| * @param newChild |
| * @param refChild |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node insertBefore(Node newChild, Node refChild) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * @param newChild |
| * @param oldChild |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node replaceChild(Node newChild, Node oldChild) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * @param oldChild |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node removeChild(Node oldChild) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * @param newChild |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node appendChild(Node newChild) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Node |
| */ |
| @Override |
| public final boolean hasChildNodes() |
| { |
| return (DTM.NULL != dtm.getFirstChild(node)); |
| } |
| |
| /** |
| * |
| * @param deep |
| * |
| * |
| * @see org.w3c.dom.Node -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node cloneNode(boolean deep) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final DocumentType getDoctype() |
| { |
| return null; |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final DOMImplementation getImplementation() |
| { |
| return implementation; |
| } |
| |
| /** This is a bit of a problem in DTM, since a DTM may be a Document |
| * Fragment and hence not have a clear-cut Document Element. We can |
| * make it work in the well-formed cases but would that be confusing for others? |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final Element getDocumentElement() |
| { |
| int dochandle=dtm.getDocument(); |
| int elementhandle=DTM.NULL; |
| for(int kidhandle=dtm.getFirstChild(dochandle); |
| kidhandle!=DTM.NULL; |
| kidhandle=dtm.getNextSibling(kidhandle)) |
| { |
| switch(dtm.getNodeType(kidhandle)) |
| { |
| case Node.ELEMENT_NODE: |
| if(elementhandle!=DTM.NULL) |
| { |
| elementhandle=DTM.NULL; // More than one; ill-formed. |
| kidhandle=dtm.getLastChild(dochandle); // End loop |
| } |
| else |
| elementhandle=kidhandle; |
| break; |
| |
| // These are harmless; document is still wellformed |
| case Node.COMMENT_NODE: |
| case Node.PROCESSING_INSTRUCTION_NODE: |
| case Node.DOCUMENT_TYPE_NODE: |
| break; |
| |
| default: |
| elementhandle=DTM.NULL; // ill-formed |
| kidhandle=dtm.getLastChild(dochandle); // End loop |
| break; |
| } |
| } |
| if(elementhandle==DTM.NULL) |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| else |
| return (Element)(dtm.getNode(elementhandle)); |
| } |
| |
| /** |
| * |
| * @param tagName |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final Element createElement(String tagName) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final DocumentFragment createDocumentFragment() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param data |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final Text createTextNode(String data) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param data |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final Comment createComment(String data) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param data |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final CDATASection createCDATASection(String data) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param target |
| * @param data |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final ProcessingInstruction createProcessingInstruction( |
| String target, String data) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param name |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final Attr createAttribute(String name) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param name |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final EntityReference createEntityReference(String name) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| /** |
| * |
| * @param tagname |
| * |
| * |
| * @see org.w3c.dom.Document |
| */ |
| @Override |
| public final NodeList getElementsByTagName(String tagname) |
| { |
| Vector listVector = new Vector(); |
| Node retNode = dtm.getNode(node); |
| if (retNode != null) |
| { |
| boolean isTagNameWildCard = "*".equals(tagname); |
| if (DTM.ELEMENT_NODE == retNode.getNodeType()) |
| { |
| NodeList nodeList = retNode.getChildNodes(); |
| for (int i = 0; i < nodeList.getLength(); i++) |
| { |
| traverseChildren(listVector, nodeList.item(i), tagname, |
| isTagNameWildCard); |
| } |
| } else if (DTM.DOCUMENT_NODE == retNode.getNodeType()) { |
| traverseChildren(listVector, dtm.getNode(node), tagname, |
| isTagNameWildCard); |
| } |
| } |
| int size = listVector.size(); |
| NodeSet nodeSet = new NodeSet(size); |
| for (int i = 0; i < size; i++) |
| { |
| nodeSet.addNode((Node) listVector.elementAt(i)); |
| } |
| return (NodeList) nodeSet; |
| } |
| |
| /** |
| * |
| * @param listVector |
| * @param tempNode |
| * @param tagname |
| * @param isTagNameWildCard |
| * |
| * |
| * Private method to be used for recursive iterations to obtain elements by tag name. |
| */ |
| private final void traverseChildren |
| ( |
| Vector listVector, |
| Node tempNode, |
| String tagname, |
| boolean isTagNameWildCard) { |
| if (tempNode == null) |
| { |
| return; |
| } |
| else |
| { |
| if (tempNode.getNodeType() == DTM.ELEMENT_NODE |
| && (isTagNameWildCard || tempNode.getNodeName().equals(tagname))) |
| { |
| listVector.add(tempNode); |
| } |
| if(tempNode.hasChildNodes()) |
| { |
| NodeList nodeList = tempNode.getChildNodes(); |
| for (int i = 0; i < nodeList.getLength(); i++) |
| { |
| traverseChildren(listVector, nodeList.item(i), tagname, |
| isTagNameWildCard); |
| } |
| } |
| } |
| } |
| |
| |
| |
| /** |
| * |
| * @param importedNode |
| * @param deep |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document as of DOM Level 2 -- DTMNodeProxy is read-only |
| */ |
| @Override |
| public final Node importNode(Node importedNode, boolean deep) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param qualifiedName |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document as of DOM Level 2 |
| */ |
| @Override |
| public final Element createElementNS( |
| String namespaceURI, String qualifiedName) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param qualifiedName |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Document as of DOM Level 2 |
| */ |
| @Override |
| public final Attr createAttributeNS( |
| String namespaceURI, String qualifiedName) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param localName |
| * |
| * |
| * @see org.w3c.dom.Document as of DOM Level 2 |
| */ |
| @Override |
| public final NodeList getElementsByTagNameNS(String namespaceURI, |
| String localName) |
| { |
| Vector listVector = new Vector(); |
| Node retNode = dtm.getNode(node); |
| if (retNode != null) |
| { |
| boolean isNamespaceURIWildCard = "*".equals(namespaceURI); |
| boolean isLocalNameWildCard = "*".equals(localName); |
| if (DTM.ELEMENT_NODE == retNode.getNodeType()) |
| { |
| NodeList nodeList = retNode.getChildNodes(); |
| for(int i = 0; i < nodeList.getLength(); i++) |
| { |
| traverseChildren(listVector, nodeList.item(i), namespaceURI, localName, isNamespaceURIWildCard, isLocalNameWildCard); |
| } |
| } |
| else if(DTM.DOCUMENT_NODE == retNode.getNodeType()) |
| { |
| traverseChildren(listVector, dtm.getNode(node), namespaceURI, localName, isNamespaceURIWildCard, isLocalNameWildCard); |
| } |
| } |
| int size = listVector.size(); |
| NodeSet nodeSet = new NodeSet(size); |
| for (int i = 0; i < size; i++) |
| { |
| nodeSet.addNode((Node)listVector.elementAt(i)); |
| } |
| return (NodeList) nodeSet; |
| } |
| /** |
| * |
| * @param listVector |
| * @param tempNode |
| * @param namespaceURI |
| * @param localname |
| * @param isNamespaceURIWildCard |
| * @param isLocalNameWildCard |
| * |
| * Private method to be used for recursive iterations to obtain elements by tag name |
| * and namespaceURI. |
| */ |
| private final void traverseChildren |
| ( |
| Vector listVector, |
| Node tempNode, |
| String namespaceURI, |
| String localname, |
| boolean isNamespaceURIWildCard, |
| boolean isLocalNameWildCard) |
| { |
| if (tempNode == null) |
| { |
| return; |
| } |
| else |
| { |
| if (tempNode.getNodeType() == DTM.ELEMENT_NODE |
| && (isLocalNameWildCard |
| || tempNode.getLocalName().equals(localname))) |
| { |
| String nsURI = tempNode.getNamespaceURI(); |
| if ((namespaceURI == null && nsURI == null) |
| || isNamespaceURIWildCard |
| || (namespaceURI != null && namespaceURI.equals(nsURI))) |
| { |
| listVector.add(tempNode); |
| } |
| } |
| if(tempNode.hasChildNodes()) |
| { |
| NodeList nl = tempNode.getChildNodes(); |
| for(int i = 0; i < nl.getLength(); i++) |
| { |
| traverseChildren(listVector, nl.item(i), namespaceURI, localname, |
| isNamespaceURIWildCard, isLocalNameWildCard); |
| } |
| } |
| } |
| } |
| /** |
| * |
| * @param elementId |
| * |
| * |
| * @see org.w3c.dom.Document as of DOM Level 2 |
| */ |
| @Override |
| public final Element getElementById(String elementId) |
| { |
| return (Element) dtm.getNode(dtm.getElementById(elementId)); |
| } |
| |
| /** |
| * |
| * @param offset |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Text |
| */ |
| @Override |
| public final Text splitText(int offset) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final String getData() throws DOMException |
| { |
| return dtm.getNodeValue(node); |
| } |
| |
| /** |
| * |
| * @param data |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final void setData(String data) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final int getLength() |
| { |
| // %OPT% This should do something smarter? |
| return dtm.getNodeValue(node).length(); |
| } |
| |
| /** |
| * |
| * @param offset |
| * @param count |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final String substringData(int offset, int count) throws DOMException |
| { |
| return getData().substring(offset,offset+count); |
| } |
| |
| /** |
| * |
| * @param arg |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final void appendData(String arg) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param offset |
| * @param arg |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final void insertData(int offset, String arg) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param offset |
| * @param count |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final void deleteData(int offset, int count) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param offset |
| * @param count |
| * @param arg |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.CharacterData |
| */ |
| @Override |
| public final void replaceData(int offset, int count, String arg) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final String getTagName() |
| { |
| return dtm.getNodeName(node); |
| } |
| |
| /** |
| * |
| * @param name |
| * |
| * |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final String getAttribute(String name) |
| { |
| DTMNamedNodeMap map = new DTMNamedNodeMap(dtm, node); |
| Node n = map.getNamedItem(name); |
| return (null == n) ? EMPTYSTRING : n.getNodeValue(); |
| } |
| |
| /** |
| * |
| * @param name |
| * @param value |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final void setAttribute(String name, String value) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param name |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final void removeAttribute(String name) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param name |
| * |
| * |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final Attr getAttributeNode(String name) |
| { |
| DTMNamedNodeMap map = new DTMNamedNodeMap(dtm, node); |
| return (Attr)map.getNamedItem(name); |
| } |
| |
| /** |
| * |
| * @param newAttr |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final Attr setAttributeNode(Attr newAttr) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param oldAttr |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final Attr removeAttributeNode(Attr oldAttr) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * Introduced in DOM Level 2. |
| * |
| * |
| */ |
| @Override |
| public boolean hasAttributes() |
| { |
| return DTM.NULL != dtm.getFirstAttribute(node); |
| } |
| |
| /** @see org.w3c.dom.Element */ |
| @Override |
| public final void normalize() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param localName |
| * |
| * |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final String getAttributeNS(String namespaceURI, String localName) |
| { |
| Node retNode = null; |
| int n = dtm.getAttributeNode(node,namespaceURI,localName); |
| if(n != DTM.NULL) |
| retNode = dtm.getNode(n); |
| return (null == retNode) ? EMPTYSTRING : retNode.getNodeValue(); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param qualifiedName |
| * @param value |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final void setAttributeNS( |
| String namespaceURI, String qualifiedName, String value) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param localName |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final void removeAttributeNS(String namespaceURI, String localName) |
| throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * @param namespaceURI |
| * @param localName |
| * |
| * |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final Attr getAttributeNodeNS(String namespaceURI, String localName) |
| { |
| Attr retAttr = null; |
| int n = dtm.getAttributeNode(node,namespaceURI,localName); |
| if(n != DTM.NULL) |
| retAttr = (Attr) dtm.getNode(n); |
| return retAttr; |
| |
| } |
| |
| /** |
| * |
| * @param newAttr |
| * |
| * |
| * |
| * @throws DOMException |
| * @see org.w3c.dom.Element |
| */ |
| @Override |
| public final Attr setAttributeNodeNS(Attr newAttr) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Attr |
| */ |
| @Override |
| public final String getName() |
| { |
| return dtm.getNodeName(node); |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Attr |
| */ |
| @Override |
| public final boolean getSpecified() |
| { |
| // We really don't know which attributes might have come from the |
| // source document versus from the DTD. Treat them all as having |
| // been provided by the user. |
| // %REVIEW% if/when we become aware of DTDs/schemae. |
| return true; |
| } |
| |
| /** |
| * |
| * |
| * @see org.w3c.dom.Attr |
| */ |
| @Override |
| public final String getValue() |
| { |
| return dtm.getNodeValue(node); |
| } |
| |
| /** |
| * |
| * @param value |
| * @see org.w3c.dom.Attr |
| */ |
| @Override |
| public final void setValue(String value) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * Get the owner element of an attribute. |
| * |
| * |
| * @see org.w3c.dom.Attr as of DOM Level 2 |
| */ |
| @Override |
| public final Element getOwnerElement() |
| { |
| if (getNodeType() != Node.ATTRIBUTE_NODE) |
| return null; |
| // In XPath and DTM data models, unlike DOM, an Attr's parent is its |
| // owner element. |
| int newnode = dtm.getParent(node); |
| return (newnode == DTM.NULL) ? null : (Element)(dtm.getNode(newnode)); |
| } |
| |
| /** |
| * NEEDSDOC Method adoptNode |
| * |
| * |
| * NEEDSDOC @param source |
| * |
| * NEEDSDOC (adoptNode) @return |
| * |
| * @throws DOMException |
| */ |
| @Override |
| public Node adoptNode(Node source) throws DOMException |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, the encoding |
| * of this document. This is <code>null</code> when unspecified. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC ($objectName$) @return |
| */ |
| @Override |
| public String getInputEncoding() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, the encoding |
| * of this document. This is <code>null</code> when unspecified. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC @param encoding |
| */ |
| public void setEncoding(String encoding) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, whether this |
| * document is standalone. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC ($objectName$) @return |
| */ |
| public boolean getStandalone() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, whether this |
| * document is standalone. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC @param standalone |
| */ |
| public void setStandalone(boolean standalone) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying whether errors checking is enforced or not. |
| * When set to <code>false</code>, the implementation is free to not |
| * test every possible error case normally defined on DOM operations, |
| * and not raise any <code>DOMException</code>. In case of error, the |
| * behavior is undefined. This attribute is <code>true</code> by |
| * defaults. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC ($objectName$) @return |
| */ |
| @Override |
| public boolean getStrictErrorChecking() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying whether errors checking is enforced or not. |
| * When set to <code>false</code>, the implementation is free to not |
| * test every possible error case normally defined on DOM operations, |
| * and not raise any <code>DOMException</code>. In case of error, the |
| * behavior is undefined. This attribute is <code>true</code> by |
| * defaults. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC @param strictErrorChecking |
| */ |
| @Override |
| public void setStrictErrorChecking(boolean strictErrorChecking) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, the version |
| * number of this document. This is <code>null</code> when unspecified. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC ($objectName$) @return |
| */ |
| public String getVersion() |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| /** |
| * <p>EXPERIMENTAL! Based on the <a |
| * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document |
| * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>. |
| * <p> |
| * An attribute specifying, as part of the XML declaration, the version |
| * number of this document. This is <code>null</code> when unspecified. |
| * @since DOM Level 3 |
| * |
| * NEEDSDOC @param version |
| */ |
| public void setVersion(String version) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| |
| |
| /** Inner class to support getDOMImplementation. |
| */ |
| static class DTMNodeProxyImplementation implements DOMImplementation |
| { |
| @Override |
| public DocumentType createDocumentType(String qualifiedName,String publicId, String systemId) |
| { |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| @Override |
| public Document createDocument(String namespaceURI,String qualfiedName,DocumentType doctype) |
| { |
| // Could create a DTM... but why, when it'd have to be permanantly empty? |
| throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR); |
| } |
| /** Ask whether we support a given DOM feature. |
| * |
| * In fact, we do not _fully_ support any DOM feature -- we're a |
| * read-only subset -- so arguably we should always return false. |
| * On the other hand, it may be more practically useful to return |
| * true and simply treat the whole DOM as read-only, failing on the |
| * methods we can't support. I'm not sure which would be more useful |
| * to the caller. |
| */ |
| @Override |
| public boolean hasFeature(String feature,String version) |
| { |
| if( ("CORE".equals(feature.toUpperCase()) || "XML".equals(feature.toUpperCase())) |
| && |
| ("1.0".equals(version) || "2.0".equals(version))) |
| return true; |
| return false; |
| } |
| |
| /** |
| * 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 |
| */ |
| @Override |
| 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 hasFeature(feature, version) ? this : null; |
| return null; //PENDING |
| } |
| |
| } |
| |
| |
| //RAMESH : Pending proper implementation of DOM Level 3 |
| |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| * 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 |
| */ |
| @Override |
| 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 |
| * 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 |
| */ |
| @Override |
| 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 |
| * Look up the prefix associated to the given namespace URI, starting from this node. |
| * |
| * @param namespaceURI |
| * @return the prefix for the namespace |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public String getTextContent() throws DOMException { |
| return dtm.getStringValue(node).toString(); |
| } |
| |
| /** |
| * 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public String getBaseURI() { |
| return null; |
| } |
| |
| /** |
| * DOM Level 3 |
| * Renaming node |
| */ |
| @Override |
| public Node renameNode(Node n, |
| String namespaceURI, |
| String name) |
| throws DOMException{ |
| return n; |
| } |
| |
| |
| /** |
| * DOM Level 3 |
| * Normalize document. |
| */ |
| @Override |
| public void normalizeDocument(){ |
| |
| } |
| /** |
| * The configuration used when <code>Document.normalizeDocument</code> is |
| * invoked. |
| * @since DOM Level 3 |
| */ |
| @Override |
| public DOMConfiguration getDomConfig(){ |
| return null; |
| } |
| |
| |
| /** DOM Level 3 feature: documentURI */ |
| protected String fDocumentURI; |
| |
| /** |
| * DOM Level 3 |
| */ |
| @Override |
| public void setDocumentURI(String documentURI){ |
| fDocumentURI= documentURI; |
| } |
| |
| /** |
| * DOM Level 3 |
| * The location of the document or <code>null</code> if undefined. |
| * <br>Beware that when the <code>Document</code> supports the feature |
| * "HTML" , the href attribute of the HTML BASE element takes precedence |
| * over this attribute. |
| * @since DOM Level 3 |
| */ |
| @Override |
| public String getDocumentURI(){ |
| return fDocumentURI; |
| } |
| |
| /**DOM Level 3 feature: Document actualEncoding */ |
| protected String actualEncoding; |
| |
| /** |
| * DOM Level 3 |
| * An attribute specifying the actual encoding of this document. This is |
| * <code>null</code> otherwise. |
| * <br> This attribute represents the property [character encoding scheme] |
| * defined in . |
| * @since DOM Level 3 |
| */ |
| public String getActualEncoding() { |
| return actualEncoding; |
| } |
| |
| /** |
| * DOM Level 3 |
| * An attribute specifying the actual encoding of this document. This is |
| * <code>null</code> otherwise. |
| * <br> This attribute represents the property [character encoding scheme] |
| * defined in . |
| * @since DOM Level 3 |
| */ |
| public void setActualEncoding(String value) { |
| actualEncoding = value; |
| } |
| |
| /** |
| * DOM Level 3 |
| */ |
| @Override |
| public Text replaceWholeText(String content) |
| throws DOMException{ |
| /* |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| |
| // make sure we can make the replacement |
| if (!canModify(nextSibling)) { |
| throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, |
| DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null)); |
| } |
| |
| Node parent = this.getParentNode(); |
| if (content == null || content.length() == 0) { |
| // remove current node |
| if (parent !=null) { // check if node in the tree |
| parent.removeChild(this); |
| return null; |
| } |
| } |
| Text currentNode = null; |
| if (isReadOnly()){ |
| Text newNode = this.ownerDocument().createTextNode(content); |
| if (parent !=null) { // check if node in the tree |
| parent.insertBefore(newNode, this); |
| parent.removeChild(this); |
| currentNode = newNode; |
| } else { |
| return newNode; |
| } |
| } else { |
| this.setData(content); |
| currentNode = this; |
| } |
| Node sibling = currentNode.getNextSibling(); |
| while ( sibling !=null) { |
| parent.removeChild(sibling); |
| sibling = currentNode.getNextSibling(); |
| } |
| |
| return currentNode; |
| */ |
| return null; //Pending |
| } |
| |
| /** |
| * DOM Level 3 |
| * Returns all text of <code>Text</code> nodes logically-adjacent text |
| * nodes to this node, concatenated in document order. |
| * @since DOM Level 3 |
| */ |
| @Override |
| public String getWholeText(){ |
| |
| /* |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| if (nextSibling == null) { |
| return data; |
| } |
| StringBuffer buffer = new StringBuffer(); |
| if (data != null && data.length() != 0) { |
| buffer.append(data); |
| } |
| getWholeText(nextSibling, buffer); |
| return buffer.toString(); |
| */ |
| return null; // PENDING |
| |
| } |
| |
| /** |
| * DOM Level 3 |
| * Returns whether this text node contains whitespace in element content, |
| * often abusively called "ignorable whitespace". |
| */ |
| @Override |
| public boolean isElementContentWhitespace(){ |
| return false; |
| } |
| |
| /** |
| * NON-DOM: set the type of this attribute to be ID type. |
| * |
| * @param id |
| */ |
| public void setIdAttribute(boolean id){ |
| //PENDING |
| } |
| |
| /** |
| * DOM Level 3: register the given attribute node as an ID attribute |
| */ |
| @Override |
| public void setIdAttribute(String name, boolean makeId) { |
| //PENDING |
| } |
| |
| |
| /** |
| * DOM Level 3: register the given attribute node as an ID attribute |
| */ |
| @Override |
| public void setIdAttributeNode(Attr at, boolean makeId) { |
| //PENDING |
| } |
| |
| /** |
| * DOM Level 3: register the given attribute node as an ID attribute |
| */ |
| @Override |
| public void setIdAttributeNS(String namespaceURI, String localName, |
| boolean makeId) { |
| //PENDING |
| } |
| /** |
| * Method getSchemaTypeInfo. |
| * @return TypeInfo |
| */ |
| @Override |
| public TypeInfo getSchemaTypeInfo(){ |
| return null; //PENDING |
| } |
| |
| @Override |
| public boolean isId() { |
| return false; //PENDING |
| } |
| |
| |
| private String xmlEncoding; |
| @Override |
| public String getXmlEncoding( ) { |
| return xmlEncoding; |
| } |
| public void setXmlEncoding( String xmlEncoding ) { |
| this.xmlEncoding = xmlEncoding; |
| } |
| |
| private boolean xmlStandalone; |
| @Override |
| public boolean getXmlStandalone() { |
| return xmlStandalone; |
| } |
| |
| @Override |
| public void setXmlStandalone(boolean xmlStandalone) throws DOMException { |
| this.xmlStandalone = xmlStandalone; |
| } |
| |
| private String xmlVersion; |
| @Override |
| public String getXmlVersion() { |
| return xmlVersion; |
| } |
| |
| @Override |
| public void setXmlVersion(String xmlVersion) throws DOMException { |
| this.xmlVersion = xmlVersion; |
| } |
| |
| } |
