Java DTM.DOCUMENT_NODE属性代码示例

/**
 *
 * @param tagname
 *
 *
 * @see org.w3c.dom.Document
 */
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 namespaceURI
 * @param localName
 *
 *
 * @see org.w3c.dom.Document as of DOM Level 2
 */
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;
}
 

/**
 * Get the head of the most likely list of associations to check, based on 
 * the name and type of the targetNode argument.
 *
 * @param xctxt The XPath runtime context.
 * @param targetNode The target node that will be checked for a match.
 * @param dtm The dtm owner for the target node.
 *
 * @return The head of a linked list that contains all possible match pattern to 
 * template associations.
 */
public TemplateSubPatternAssociation getHead(XPathContext xctxt, 
                                             int targetNode, DTM dtm)
{
  short targetNodeType = dtm.getNodeType(targetNode);
  TemplateSubPatternAssociation head;

  switch (targetNodeType)
  {
  case DTM.ELEMENT_NODE :
  case DTM.ATTRIBUTE_NODE :
    head = (TemplateSubPatternAssociation) m_patternTable.get(
      dtm.getLocalName(targetNode));
    break;
  case DTM.TEXT_NODE :
  case DTM.CDATA_SECTION_NODE :
    head = m_textPatterns;
    break;
  case DTM.ENTITY_REFERENCE_NODE :
  case DTM.ENTITY_NODE :
    head = (TemplateSubPatternAssociation) m_patternTable.get(
      dtm.getNodeName(targetNode)); // %REVIEW% I think this is right
    break;
  case DTM.PROCESSING_INSTRUCTION_NODE :
    head = (TemplateSubPatternAssociation) m_patternTable.get(
      dtm.getLocalName(targetNode));
    break;
  case DTM.COMMENT_NODE :
    head = m_commentPatterns;
    break;
  case DTM.DOCUMENT_NODE :
  case DTM.DOCUMENT_FRAGMENT_NODE :
    head = m_docPatterns;
    break;
  case DTM.NOTATION_NODE :
  default :
    head = (TemplateSubPatternAssociation) m_patternTable.get(
      dtm.getNodeName(targetNode)); // %REVIEW% I think this is right
  }

  return (null == head) ? m_wildCardPatterns : head;
}
 

/**
 * The xsl:copy element provides an easy way of copying the current node.
 * Executing this function creates a copy of the current node into the
 * result tree.
 * <p>The namespace nodes of the current node are automatically
 * copied as well, but the attributes and children of the node are not
 * automatically copied. The content of the xsl:copy element is a
 * template for the attributes and children of the created node;
 * the content is instantiated only for nodes of types that can have
 * attributes or children (i.e. root nodes and element nodes).</p>
 * <p>The root node is treated specially because the root node of the
 * result tree is created implicitly. When the current node is the
 * root node, xsl:copy will not create a root node, but will just use
 * the content template.</p>
 *
 * @param transformer non-null reference to the the current transform-time state.
 *
 * @throws TransformerException
 */
public void execute(
        TransformerImpl transformer)
          throws TransformerException
{
              XPathContext xctxt = transformer.getXPathContext();
    
  try
  {
    int sourceNode = xctxt.getCurrentNode();
    xctxt.pushCurrentNode(sourceNode);
    DTM dtm = xctxt.getDTM(sourceNode);
    short nodeType = dtm.getNodeType(sourceNode);

    if ((DTM.DOCUMENT_NODE != nodeType) && (DTM.DOCUMENT_FRAGMENT_NODE != nodeType))
    {
      SerializationHandler rthandler = transformer.getSerializationHandler();

      // TODO: Process the use-attribute-sets stuff
      ClonerToResultTree.cloneToResultTree(sourceNode, nodeType, dtm, 
                                           rthandler, false);

      if (DTM.ELEMENT_NODE == nodeType)
      {
        super.execute(transformer);
        SerializerUtils.processNSDecls(rthandler, sourceNode, nodeType, dtm);
        transformer.executeChildTemplates(this, true);
        
        String ns = dtm.getNamespaceURI(sourceNode);
        String localName = dtm.getLocalName(sourceNode);
        transformer.getResultTreeHandler().endElement(ns, localName,
                                                      dtm.getNodeName(sourceNode));
      }
    }
    else
    {
      super.execute(transformer);
      transformer.executeChildTemplates(this, true);
    }
  }
  catch(org.xml.sax.SAXException se)
  {
    throw new TransformerException(se);
  }
  finally
  {
    xctxt.popCurrentNode();
  }
}
 

/**
 * End processing of given node 
 *
 *
 * @param node Node we just finished processing
 *
 * @throws org.xml.sax.SAXException
 */
protected void endNode(int node) throws org.xml.sax.SAXException
{

  switch (m_dtm.getNodeType(node))
  {
  case DTM.DOCUMENT_NODE :
    this.m_contentHandler.endDocument();
    break;
  case DTM.ELEMENT_NODE :
    String ns = m_dtm.getNamespaceURI(node);
    if(null == ns)
      ns = "";
    this.m_contentHandler.endElement(ns,
                                       m_dtm.getLocalName(node),
                                       m_dtm.getNodeName(node));

    for (int nsn = m_dtm.getFirstNamespaceNode(node, true); DTM.NULL != nsn;
         nsn = m_dtm.getNextNamespaceNode(node, nsn, true))
    {
      // String prefix = m_dtm.getPrefix(nsn);
      String prefix = m_dtm.getNodeNameX(nsn);

      this.m_contentHandler.endPrefixMapping(prefix);
    }
    break;
  case DTM.CDATA_SECTION_NODE :
    break;
  case DTM.ENTITY_REFERENCE_NODE :
  {
    if (m_contentHandler instanceof LexicalHandler)
    {
      LexicalHandler lh = ((LexicalHandler) this.m_contentHandler);

      lh.endEntity(m_dtm.getNodeName(node));
    }
  }
  break;
  default :
  }
}
 

/**
 * Tell what node type to test, if not DTMFilter.SHOW_ALL.
 *
 * @param whatToShow Bit set defined mainly by 
 *        {@link org.apache.xml.dtm.DTMFilter}.
 * @return the node type for the whatToShow.  Since whatToShow can specify 
 *         multiple types, it will return the first bit tested that is on, 
 *         so the caller of this function should take care that this is 
 *         the function they really want to call.  If none of the known bits
 *         are set, this function will return zero.
 */
public static int getNodeTypeTest(int whatToShow)
{
  // %REVIEW% Is there a better way?
  if (0 != (whatToShow & DTMFilter.SHOW_ELEMENT))
    return DTM.ELEMENT_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_ATTRIBUTE))
    return DTM.ATTRIBUTE_NODE;
    
  if (0 != (whatToShow & DTMFilter.SHOW_TEXT))
    return DTM.TEXT_NODE;
    
  if (0 != (whatToShow & DTMFilter.SHOW_DOCUMENT))
    return DTM.DOCUMENT_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_DOCUMENT_FRAGMENT))
    return DTM.DOCUMENT_FRAGMENT_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_NAMESPACE))
    return DTM.NAMESPACE_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_COMMENT))
    return DTM.COMMENT_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_PROCESSING_INSTRUCTION))
    return DTM.PROCESSING_INSTRUCTION_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_DOCUMENT_TYPE))
    return DTM.DOCUMENT_TYPE_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_ENTITY))
    return DTM.ENTITY_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_ENTITY_REFERENCE))
    return DTM.ENTITY_REFERENCE_NODE;

  if (0 != (whatToShow & DTMFilter.SHOW_NOTATION))
    return DTM.NOTATION_NODE;
    
  if (0 != (whatToShow & DTMFilter.SHOW_CDATA_SECTION))
    return DTM.CDATA_SECTION_NODE;


  return 0;
}
 

/**
 * Given a node handle, find the owning document node, using DTM semantics
 * (Document owns itself) rather than DOM semantics (Document has no owner).
 *
 * (I'm counting on the fact that getOwnerDocument() is implemented on top
 * of this call, in the superclass, to avoid having to rewrite that one.
 * Be careful if that code changes!)
 *
 * @param nodeHandle the id of the node.
 * @return int Node handle of owning document
 */
public int getDocumentRoot(int nodeHandle)
{
  for (int id=makeNodeIdentity(nodeHandle); id!=NULL; id=_parent(id)) {
    if (_type(id)==DTM.DOCUMENT_NODE) {
      return makeNodeHandle(id);
    }
  }

  return DTM.NULL; // Safety net; should never happen
}
 

/**
 * Get the type of the node.  We'll pretend we're a Document.
 *
 * @return the type of the node: document node.
 */
public short getNodeType()
{
  return DTM.DOCUMENT_NODE;
}