FileDocCategorySizeDatePackage
DOM2Helper.javaAPI DocJava SE 6 API10500Tue Jun 10 00:23:10 BST 2008com.sun.org.apache.xml.internal.utils

DOM2Helper

public class DOM2Helper extends DOMHelper
deprecated
Since the introduction of the DTM, this class will be removed. This class provides a DOM level 2 "helper", which provides services currently not provided be the DOM standard.

Fields Summary
private Document
m_doc
Field m_doc: Document Node for the document this helper is currently accessing or building
Constructors Summary
public DOM2Helper()
Construct an instance.

Methods Summary
public voidcheckNode(org.w3c.dom.Node node)
Check node to see if it was created by a DOM implementation that this helper is intended to support. This is currently disabled, and assumes all nodes are acceptable rather than checking that they implement com.sun.org.apache.xerces.internal.dom.NodeImpl.

param
node The node to be tested.
throws
TransformerException if the node is not one which this DOM2Helper can support. If we return without throwing the exception, the node is compatable.
xsl.usage
internal


    // if(!(node instanceof com.sun.org.apache.xerces.internal.dom.NodeImpl))
    //  throw new TransformerException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_XERCES_CANNOT_HANDLE_NODES, new Object[]{((Object)node).getClass()})); //"DOM2Helper can not handle nodes of type"
    //+((Object)node).getClass());
  
public org.w3c.dom.DocumentgetDocument()
Query which document this helper is currently operating on.

return
The DOM Document node for this document.
see
#setDocument

    return m_doc;
  
public org.w3c.dom.ElementgetElementByID(java.lang.String id, org.w3c.dom.Document doc)
Given an XML ID, return the element. This requires assistance from the DOM and parser, and is meaningful only in the context of a DTD or schema which declares attributes as being of type ID. This information may or may not be available in all parsers, may or may not be available for specific documents, and may or may not be available when validation is not turned on.

param
id The ID to search for, as a String.
param
doc The document to search within, as a DOM Document node.
return
DOM Element node with an attribute of type ID whose value uniquely matches the requested id string, or null if there isn't such an element or if the DOM can't answer the question for other reasons.

    return doc.getElementById(id);
  
public java.lang.StringgetLocalNameOfNode(org.w3c.dom.Node n)
Returns the local name of the given node, as defined by the XML Namespaces specification. This is prepared to handle documents built using DOM Level 1 methods by falling back upon explicitly parsing the node name.

param
n Node to be examined
return
String containing the local name, or null if the node was not assigned a Namespace.


    String name = n.getLocalName();

    return (null == name) ? super.getLocalNameOfNode(n) : name;
  
public java.lang.StringgetNamespaceOfNode(org.w3c.dom.Node n)
Returns the Namespace Name (Namespace URI) for the given node. In a Level 2 DOM, you can ask the node itself. Note, however, that doing so conflicts with our decision in getLocalNameOfNode not to trust the that the DOM was indeed created using the Level 2 methods. If Level 1 methods were used, these two functions will disagree with each other.

TODO: Reconcile with getLocalNameOfNode.

param
n Node to be examined
return
String containing the Namespace URI bound to this DOM node at the time the Node was created.

    return n.getNamespaceURI();
  
public static org.w3c.dom.NodegetParentOfNode(org.w3c.dom.Node node)
Get the XPath-model parent of a node. This version takes advantage of the DOM Level 2 Attr.ownerElement() method; the base version we would otherwise inherit is prepared to fall back on exhaustively walking the document to find an Attr's parent.

param
node Node to be examined
return
the DOM parent of the input node, if there is one, or the ownerElement if the input node is an Attr, or null if the node is a Document, a DocumentFragment, or an orphan.

          Node parent=node.getParentNode();
          if(parent==null && (Node.ATTRIBUTE_NODE == node.getNodeType()) )
           parent=((Attr) node).getOwnerElement();
          return parent;
  
public static booleanisNodeAfter(org.w3c.dom.Node node1, org.w3c.dom.Node node2)
Figure out whether node2 should be considered as being later in the document than node1, in Document Order as defined by the XPath model. This may not agree with the ordering defined by other XML applications.

There are some cases where ordering isn't defined, and neither are the results of this function -- though we'll generally return true.

TODO: Make sure this does the right thing with attribute nodes!!!

param
node1 DOM Node to perform position comparison on.
param
node2 DOM Node to perform position comparison on .
return
false if node2 comes before node1, otherwise return true. You can think of this as (node1.documentOrderPosition <= node2.documentOrderPosition).


    // Assume first that the nodes are DTM nodes, since discovering node 
    // order is massivly faster for the DTM.
    if(node1 instanceof DOMOrder && node2 instanceof DOMOrder)
    {
      int index1 = ((DOMOrder) node1).getUid();
      int index2 = ((DOMOrder) node2).getUid();

      return index1 <= index2;
    }
    else
    {

      // isNodeAfter will return true if node is after countedNode 
      // in document order. The base isNodeAfter is sloooow (relatively).
      return DOMHelper.isNodeAfter(node1, node2);
    }
  
public voidparse(org.xml.sax.InputSource source)
Parse an XML document.

Right now the Xerces DOMParser class is used. This needs fixing, either via jaxp, or via some other, standard method.

The application can use this method to instruct the SAX parser to begin parsing an XML document from any valid input source (a character stream, a byte stream, or a URI).

Applications may not invoke this method while a parse is in progress (they should create a new Parser instead for each additional XML document). Once a parse is complete, an application may reuse the same Parser object, possibly with a different input source.

param
source The input source for the top-level of the XML document.
throws
TransformerException if any checked exception is thrown.
xsl.usage
internal


    try
    {

      // I guess I should use JAXP factory here... when it's legal.
      // com.sun.org.apache.xerces.internal.parsers.DOMParser parser 
      //  = new com.sun.org.apache.xerces.internal.parsers.DOMParser();
      DocumentBuilderFactory builderFactory =
        DocumentBuilderFactory.newInstance();

      builderFactory.setNamespaceAware(true);
      builderFactory.setValidating(true);

      DocumentBuilder parser = builderFactory.newDocumentBuilder();

      /*
      // domParser.setFeature("http://apache.org/xml/features/dom/create-entity-ref-nodes", getShouldExpandEntityRefs()? false : true);
      if(m_useDOM2getNamespaceURI)
      {
      parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", true);
      parser.setFeature("http://xml.org/sax/features/namespaces", true);
      }
      else
      {
      parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", false);
      }

      parser.setFeature("http://apache.org/xml/features/allow-java-encodings", true);
      */

      parser.setErrorHandler(
        new com.sun.org.apache.xml.internal.utils.DefaultErrorHandler());

      // if(null != m_entityResolver)
      // {
      // System.out.println("Setting the entity resolver.");
      //  parser.setEntityResolver(m_entityResolver);
      // }
      setDocument(parser.parse(source));
    }
    catch (org.xml.sax.SAXException se)
    {
      throw new TransformerException(se);
    }
    catch (ParserConfigurationException pce)
    {
      throw new TransformerException(pce);
    }
    catch (IOException ioe)
    {
      throw new TransformerException(ioe);
    }

    // setDocument(((com.sun.org.apache.xerces.internal.parsers.DOMParser)parser).getDocument());
  
public voidsetDocument(org.w3c.dom.Document doc)
Specify which document this helper is currently operating on.

param
doc The DOM Document node for this document.
see
#getDocument

    m_doc = doc;
  
public booleansupportsSAX()
Returns true if the DOM implementation handled by this helper supports the SAX ContentHandler interface.

return
true (since Xerces does).

    return true;