net.sf.saxon.dom.DocumentOverNodeInfo Maven / Gradle / Ivy
Show all versions of saxon9 Show documentation
package net.sf.saxon.dom;
import net.sf.saxon.om.Axis;
import net.sf.saxon.om.AxisIterator;
import net.sf.saxon.om.DocumentInfo;
import net.sf.saxon.om.NodeInfo;
import net.sf.saxon.type.Type;
import net.sf.saxon.pattern.NodeKindTest;
import org.w3c.dom.*;
import java.util.ArrayList;
/**
* This class is an implementation of the DOM Document class that wraps a Saxon DocumentInfo
* representation of a document node.
*/
public class DocumentOverNodeInfo extends NodeOverNodeInfo implements Document {
/**
* Get the Document Type Declaration (see DocumentType )
* associated with this document. For HTML documents as well as XML
* documents without a document type declaration this returns
* null. DOM method.
* @return null: The Saxon tree model does not include the document type
* information.
*/
public DocumentType getDoctype() {
return null;
}
/**
* Get a DOMImplementation object that handles this document.
* A DOM application may use objects from multiple implementations.
* DOM method.
*/
public DOMImplementation getImplementation() {
return new DOMImplementationImpl();
}
/**
* Creates an element of the type specified. DOM method: always fails,
* because the Saxon tree is not updateable.
*/
public Element createElement(String tagName) throws DOMException {
disallowUpdate();
return null;
}
/**
* Creates an empty DocumentFragment object.
* @return A new DocumentFragment .
* DOM method: returns null, because the Saxon tree is not updateable.
*/
public DocumentFragment createDocumentFragment() {
return null;
}
/**
* Create a Text node given the specified string.
* DOM method: returns null, because the Saxon tree is not updateable.
* @param data The data for the node.
* @return The new Text object.
*/
public Text createTextNode(String data) {
return null;
}
/**
* Create a Comment node given the specified string.
* DOM method: returns null, because the Saxon tree is not updateable.
* @param data The data for the node.
* @return The new Comment object.
*/
public Comment createComment(String data) {
return null;
}
/**
* Create a CDATASection node whose value is the specified
* string.
* DOM method: always fails, because the Saxon tree is not updateable.
* @param data The data for the CDATASection contents.
* @return The new CDATASection object.
* @exception org.w3c.dom.DOMException
* NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public CDATASection createCDATASection(String data) throws DOMException {
disallowUpdate();
return null;
}
/**
* Create a ProcessingInstruction node given the specified
* name and data strings.
* DOM method: returns null, because the Saxon tree is not updateable.
* @param target The target part of the processing instruction.
* @param data The data for the node.
* @return The new ProcessingInstruction object.
* @exception org.w3c.dom.DOMException
* INVALID_CHARACTER_ERR: Raised if the specified target contains an
* illegal character.
*
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public ProcessingInstruction createProcessingInstruction(String target,
String data)
throws DOMException {
disallowUpdate();
return null;
}
/**
* Create an Attr of the given name.
* DOM method: always fails, because the Saxon tree is not updateable.
* @param name The name of the attribute.
* @return A new Attr object with the nodeName
* attribute set to name , and localName ,
* prefix , and namespaceURI set to
* null .
* @exception org.w3c.dom.DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*/
public Attr createAttribute(String name) throws DOMException {
disallowUpdate();
return null;
}
/**
* Create an EntityReference object.
* DOM method: returns null, because the Saxon tree is not updateable.
* @param name The name of the entity to reference.
* @return The new EntityReference object.
* @exception org.w3c.dom.DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
*
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
*/
public EntityReference createEntityReference(String name) throws DOMException {
disallowUpdate();
return null;
}
/**
* Return a NodeList of all the Elements with
* a given tag name in the order in which they are encountered in a
* preorder traversal of the Document tree.
* @param tagname The name of the tag to match on. The special value "*"
* matches all tags.
* @return A new NodeList object containing all the matched
* Elements .
*/
public NodeList getElementsByTagName(String tagname) {
return getElementsByTagName(node, tagname);
}
/**
* Get the outermost element of a document.
* @return the Element for the outermost element of the document. If the document is
* not well-formed, this returns the first element child of the root if there is one, otherwise
* null.
*/
public Element getDocumentElement() {
NodeInfo root = node.getDocumentRoot();
if (root==null) {
return null;
}
AxisIterator children =
root.iterateAxis(Axis.CHILD, NodeKindTest.ELEMENT);
return (Element)wrap((NodeInfo)children.next());
}
protected static NodeList getElementsByTagName(NodeInfo node, String tagname) {
AxisIterator allElements = node.iterateAxis(Axis.DESCENDANT);
ArrayList nodes = new ArrayList(100);
while(true) {
NodeInfo next = (NodeInfo)allElements.next();
if (next == null) {
break;
}
if (next.getNodeKind()==Type.ELEMENT) {
if (tagname.equals("*") || tagname.equals(next.getDisplayName())) {
nodes.add(NodeOverNodeInfo.wrap(next));
}
}
}
return new DOMNodeList(nodes);
}
/**
* Import a node from another document to this document.
* DOM method: always fails, because the Saxon tree is not updateable.
* @exception org.w3c.dom.DOMException
* @since DOM Level 2
*/
public Node importNode(Node importedNode, boolean deep) throws DOMException {
disallowUpdate();
return null;
}
/**
* Create an element of the given qualified name and namespace URI.
* HTML-only DOM implementations do not need to implement this method.
* DOM method: always fails, because the Saxon tree is not updateable.
* @param namespaceURI The namespace URI of the element to create.
* @param qualifiedName The qualified name of the element type to
* instantiate.
* @return A new Element object
* @exception org.w3c.dom.DOMException
*/
public Element createElementNS(String namespaceURI,
String qualifiedName)
throws DOMException
{
disallowUpdate();
return null;
}
/**
* Create an attribute of the given qualified name and namespace URI.
* HTML-only DOM implementations do not need to implement this method.
* DOM method: returns null, because the Saxon tree is not updateable.
* @param namespaceURI The namespace URI of the attribute to create.
* @param qualifiedName The qualified name of the attribute to
* instantiate.
* @return A new Attr object.
* @exception org.w3c.dom.DOMException
*/
public Attr createAttributeNS(String namespaceURI,
String qualifiedName)
throws DOMException {
disallowUpdate();
return null;
}
/**
* Return a NodeList of all the Elements with
* a given local name and namespace URI in the order in which they are
* encountered in a preorder traversal of the Document tree.
* DOM method.
* @param namespaceURI The namespace URI of the elements to match on.
* The special value "*" matches all namespaces. The value null matches
* elements not in any namespace
* @param localName The local name of the elements to match on. The
* special value "*" matches all local names.
* @return A new NodeList object containing all the matched
* Elements .
* @since DOM Level 2
*/
public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
return getElementsByTagNameNS(node, namespaceURI, localName);
}
public static NodeList getElementsByTagNameNS(NodeInfo node, String namespaceURI, String localName) {
String ns = (namespaceURI==null ? "" : namespaceURI);
AxisIterator allElements = node.iterateAxis(Axis.DESCENDANT);
ArrayList nodes = new ArrayList(100);
while(true) {
NodeInfo next = (NodeInfo)allElements.next();
if (next == null) {
break;
}
if (next.getNodeKind()==Type.ELEMENT) {
if ((ns.equals("*") || ns.equals(next.getURI())) &&
(localName.equals("*") || localName.equals(next.getLocalPart()))) {
nodes.add(NodeOverNodeInfo.wrap(next));
}
}
}
return new DOMNodeList(nodes);
}
/**
* Return the Element whose ID is given by
* elementId . If no such element exists, returns
* null . Behavior is not defined if more than one element
* has this ID . The DOM implementation must have
* information that says which attributes are of type ID. Attributes with
* the name "ID" are not of type ID unless so defined. Implementations
* that do not know whether attributes are of type ID or not are expected
* to return null .
* @param elementId The unique id value for an element.
* @return The matching element, or null if there is none.
* @since DOM Level 2
*/
public Element getElementById(String elementId) {
// Defined on Document node; but we support it on any node.
DocumentInfo doc = node.getDocumentRoot();
if (doc == null) {
return null;
}
return (Element)wrap(doc.selectID(elementId));
}
/**
* An attribute specifying the encoding used for this document at the time
* of the parsing. This is null when it is not known, such
* as when the Document was created in memory.
*
* @since DOM Level 3
*/
public String getInputEncoding() {
return null;
}
/**
* An attribute specifying, as part of the
* XML declaration,
* the encoding of this document. This is null when
* unspecified or when it is not known, such as when the
* Document was created in memory.
*
* @since DOM Level 3
*/
public String getXmlEncoding() {
return null;
}
/**
* An attribute specifying, as part of the
* XML declaration,
* whether this document is standalone. This is false when
* unspecified.
* Note: No verification is done on the value when setting
* this attribute. Applications should use
* Document.normalizeDocument() with the "validate"
* parameter to verify if the value matches the validity
* constraint for standalone document declaration as defined in [XML 1.0].
*
* @since DOM Level 3
*/
public boolean getXmlStandalone() {
return false;
}
/**
* An attribute specifying, as part of the XML declaration, whether this document is standalone. This is false when
* unspecified.
*
Note: No verification is done on the value when setting
* this attribute. Applications should use
* Document.normalizeDocument() with the "validate"
* parameter to verify if the value matches the validity
* constraint for standalone document declaration as defined in [XML 1.0].
*
* @throws org.w3c.dom.DOMException NOT_SUPPORTED_ERR: Raised if this document does not support the
* "XML" feature.
* @since DOM Level 3
*/
public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
disallowUpdate();
}
/**
* An attribute specifying, as part of the XML declaration, the version number of this document. If there is no declaration and if
* this document supports the "XML" feature, the value is
* "1.0". If this document does not support the "XML"
* feature, the value is always null. Changing this
* attribute will affect methods that check for invalid characters in
* XML names. Application should invoke
* Document.normalizeDocument() in order to check for
* invalid characters in the Nodes that are already part of
* this Document.
*
DOM applications may use the
* DOMImplementation.hasFeature(feature, version) method
* with parameter values "XMLVersion" and "1.0" (respectively) to
* determine if an implementation supports [XML 1.0]. DOM
* applications may use the same method with parameter values
* "XMLVersion" and "1.1" (respectively) to determine if an
* implementation supports [XML 1.1]. In both
* cases, in order to support XML, an implementation must also support
* the "XML" feature defined in this specification. Document
* objects supporting a version of the "XMLVersion" feature must not
* raise a NOT_SUPPORTED_ERR exception for the same version
* number when using Document.xmlVersion.
*
* @since DOM Level 3
*/
public String getXmlVersion() {
return "1.0";
}
/**
* An attribute specifying, as part of the XML declaration, the version number of this document. If there is no declaration and if
* this document supports the "XML" feature, the value is
* "1.0". If this document does not support the "XML"
* feature, the value is always null. Changing this
* attribute will affect methods that check for invalid characters in
* XML names. Application should invoke
* Document.normalizeDocument() in order to check for
* invalid characters in the Nodes that are already part of
* this Document.
*
DOM applications may use the
* DOMImplementation.hasFeature(feature, version) method
* with parameter values "XMLVersion" and "1.0" (respectively) to
* determine if an implementation supports [XML 1.0]. DOM
* applications may use the same method with parameter values
* "XMLVersion" and "1.1" (respectively) to determine if an
* implementation supports [XML 1.1]. In both
* cases, in order to support XML, an implementation must also support
* the "XML" feature defined in this specification. Document
* objects supporting a version of the "XMLVersion" feature must not
* raise a NOT_SUPPORTED_ERR exception for the same version
* number when using Document.xmlVersion.
*
* @throws org.w3c.dom.DOMException NOT_SUPPORTED_ERR: Raised if the version is set to a value that is
* not supported by this Document or if this document
* does not support the "XML" feature.
* @since DOM Level 3
*/
public void setXmlVersion(String xmlVersion) throws DOMException {
disallowUpdate();
}
/**
* An attribute specifying whether error checking is enforced or not. When
* set to false, the implementation is free to not test
* every possible error case normally defined on DOM operations, and not
* raise any DOMException on DOM operations or report
* errors while using Document.normalizeDocument(). In case
* of error, the behavior is undefined. This attribute is
* true by default.
*
* @since DOM Level 3
*/
public boolean getStrictErrorChecking() {
return false;
}
/**
* An attribute specifying whether error checking is enforced or not. When
* set to false, the implementation is free to not test
* every possible error case normally defined on DOM operations, and not
* raise any DOMException on DOM operations or report
* errors while using Document.normalizeDocument(). In case
* of error, the behavior is undefined. This attribute is
* true by default.
*
* @since DOM Level 3
*/
public void setStrictErrorChecking(boolean strictErrorChecking) {
//no-op
}
/**
* The location of the document or null if undefined or if
* the Document was created using
* DOMImplementation.createDocument. No lexical checking is
* performed when setting this attribute; this could result in a
* null value returned when using Node.baseURI
* .
*
Beware that when the Document supports the feature
* "HTML" [DOM Level 2 HTML]
* , the href attribute of the HTML BASE element takes precedence over
* this attribute when computing Node.baseURI.
*
* @since DOM Level 3
*/
public String getDocumentURI() {
return node.getSystemId();
}
/**
* The location of the document or null if undefined or if
* the Document was created using
* DOMImplementation.createDocument. No lexical checking is
* performed when setting this attribute; this could result in a
* null value returned when using Node.baseURI
* .
*
Beware that when the Document supports the feature
* "HTML" [DOM Level 2 HTML]
* , the href attribute of the HTML BASE element takes precedence over
* this attribute when computing Node.baseURI.
*
* @since DOM Level 3
*/
public void setDocumentURI(String documentURI) {
disallowUpdate();
}
/**
* Attempts to adopt a node from another document to this document. If
* supported, it changes the ownerDocument of the source
* node, its children, as well as the attached attribute nodes if there
* are any. If the source node has a parent it is first removed from the
* child list of its parent. This effectively allows moving a subtree
* from one document to another (unlike importNode() which
* create a copy of the source node instead of moving it). When it
* fails, applications should use Document.importNode()
* instead. Note that if the adopted node is already part of this
* document (i.e. the source and target document are the same), this
* method still has the effect of removing the source node from the
* child list of its parent, if any. The following list describes the
* specifics for each type of node.
*
* - ATTRIBUTE_NODE
* - The
*
ownerElement attribute is set to null and
* the specified flag is set to true on the
* adopted Attr. The descendants of the source
* Attr are recursively adopted.
* - DOCUMENT_FRAGMENT_NODE
* - The
* descendants of the source node are recursively adopted.
* - DOCUMENT_NODE
* -
*
Document nodes cannot be adopted.
* - DOCUMENT_TYPE_NODE
* -
*
DocumentType nodes cannot be adopted.
* - ELEMENT_NODE
* - Specified attribute nodes of the source element are adopted. Default attributes
* are discarded, though if the document being adopted into defines
* default attributes for this element name, those are assigned. The
* descendants of the source element are recursively adopted.
* - ENTITY_NODE
* -
*
Entity nodes cannot be adopted.
* - ENTITY_REFERENCE_NODE
* - Only
* the
EntityReference node itself is adopted, the
* descendants are discarded, since the source and destination documents
* might have defined the entity differently. If the document being
* imported into provides a definition for this entity name, its value
* is assigned.
* - NOTATION_NODE
* Notation nodes cannot be
* adopted.- PROCESSING_INSTRUCTION_NODE, TEXT_NODE, CDATA_SECTION_NODE,
* COMMENT_NODE
* - These nodes can all be adopted. No specifics.
*
* Note: Since it does not create new nodes unlike the
* Document.importNode() method, this method does not raise
* an INVALID_CHARACTER_ERR exception, and applications
* should use the Document.normalizeDocument() method to
* check if an imported name is not an XML name according to the XML
* version in use.
*
* @param source The node to move into this document.
* @return The adopted node, or null if this operation
* fails, such as when the source node comes from a different
* implementation.
* @throws org.w3c.dom.DOMException NOT_SUPPORTED_ERR: Raised if the source node is of type
* DOCUMENT, DOCUMENT_TYPE.
*
NO_MODIFICATION_ALLOWED_ERR: Raised when the source node is
* readonly.
* @since DOM Level 3
*/
public Node adoptNode(Node source) throws DOMException {
disallowUpdate();
return null;
}
/**
* The configuration used when Document.normalizeDocument()
* is invoked.
*
* @since DOM Level 3
*/
public DOMConfiguration getDomConfig() {
return null;
}
/**
* This method acts as if the document was going through a save and load
* cycle, putting the document in a "normal" form. As a consequence,
* this method updates the replacement tree of
* EntityReference nodes and normalizes Text
* nodes, as defined in the method Node.normalize().
*
Otherwise, the actual result depends on the features being set on
* the Document.domConfig object and governing what
* operations actually take place. Noticeably this method could also
* make the document namespace well-formed according to the algorithm
* described in , check the character normalization, remove the
* CDATASection nodes, etc. See
* DOMConfiguration for details.
*
// Keep in the document
* the information defined // in the XML Information Set (Java example)
* DOMConfiguration docConfig = myDocument.getDomConfig();
* docConfig.setParameter("infoset", Boolean.TRUE);
* myDocument.normalizeDocument();
*
*
Mutation events, when supported, are generated to reflect the
* changes occurring on the document.
*
If errors occur during the invocation of this method, such as an
* attempt to update a read-only node or a Node.nodeName
* contains an invalid character according to the XML version in use,
* errors or warnings (DOMError.SEVERITY_ERROR or
* DOMError.SEVERITY_WARNING) will be reported using the
* DOMErrorHandler object associated with the "error-handler
* " parameter. Note this method might also report fatal errors (
* DOMError.SEVERITY_FATAL_ERROR) if an implementation
* cannot recover from an error.
*
* @since DOM Level 3
*/
public void normalizeDocument() {
disallowUpdate();
}
/**
* Rename an existing node of type ELEMENT_NODE or
* ATTRIBUTE_NODE. Not supported in this implementation
*
* @param n The node to rename.
* @param namespaceURI The new namespace URI.
* @param qualifiedName The new qualified name.
* @return The renamed node. This is either the specified node or the new
* node that was created to replace the specified node.
* @throws org.w3c.dom.DOMException
*/
public Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
disallowUpdate();
return null;
}
}
//
// The contents of this file are subject to the Mozilla Public License Version 1.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.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
// See the License for the specific language governing rights and limitations under the License.
//
// The Original Code is: all this file.
//
// The Initial Developer of the Original Code is Michael H. Kay.
//
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
//
// Contributor(s): none.
//