Java Node.getChildCount方法代码示例

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Generate a DOMList of all the text nodes of pNode, in document order.
 * @param pNode The target node.
 * @param pDeep If true, recurse through child nodes adding their text nodes too.
 * @return A DOMList of text nodes.
 */
@Override
public final DOMList childTextNodesAsDOMList(Node pNode, boolean pDeep){
  DOMList lList = new DOMList();
  for(int i=0; i < pNode.getChildCount(); i++){
    if(pNode.getChild(i) instanceof Text){
      //Wrap text nodes in DOMs
      lList.add(new DOM(pNode.getChild(i)));
    }
    else if (pDeep) {
      //Recurse through non-text children
      lList.addAll(childTextNodesAsDOMList(pNode.getChild(i), true));
    }
  }
  return lList;
}
 

import nu.xom.Node; //导入方法依赖的package包/类
public void serializeNodeContents(Node pNode) {
  try {
    startSerialiser();
    for(int i=0; i < pNode.getChildCount(); i++) {
      writeChild(pNode.getChild(i));
      //Place line breaks between elements
      if(mPrettyPrint && (pNode instanceof Element || pNode instanceof Comment || pNode instanceof ProcessingInstruction || pNode instanceof DocType) && i < pNode.getChildCount() - 1) {
        breakLine();
      }
    }
    flush();
  }
  catch (IOException e) {
    throw new ExInternal("XML serialisation failed", e);
  }
}
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Moves all the children of pNode into pNewParent. pNode is left as is.
 * @param pNode The Node to copy children from.
 * @param pNewParent The new parent for pNode's children.
 */
public void moveContentsTo(Node pNode, Node pNewParent) {
  //if no children, do nothing
  if(pNode.getChildCount() == 0){
    return;
  }

  //This is a LIVE list so read off the front until it's depleted
  Node lChild;
  while((lChild = (pNode.getChild(0))) != null) {
    moveToParent(lChild, pNewParent);
  }
}
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Copies all the children of pNode into pNewParent. pNode is left as is.
 * @param pNode The Node to copy children from.
 * @param pNewParent The new parent for pNode's children.
 * @param pResetRefs If true, foxids will be reset.
 */
public void copyContentsTo(Node pNode, Node pNewParent, boolean pResetRefs){
  for(int i=0; i<pNode.getChildCount(); i++){
    Node lChild = pNode.getChild(i);
    copyToParent(lChild, pNewParent, pResetRefs);
  }
}
 

import nu.xom.Node; //导入方法依赖的package包/类
public void setText(Node pNode, String pNewText) {

    mDocControl.setDocumentModifiedCount();

    // Cast to Element (checks is an element)
    Element lElement;
    try {
      lElement = (Element)pNode;
    }
    catch (ClassCastException x) {
      if(pNode instanceof Attribute) {
        Attribute lAttr = (Attribute) pNode;
        lAttr.setValue(XFUtil.nvl(pNewText, "")); // XOM cannot set attribute to null, must be empty string
        return;
      }
      else {
        throw new ExInternal("Cannot setText() on xml node of type "+pNode.getClass().getName(), x);
      }
    }

    // Remove all existing child text nodes
    for(int i = 0; i < pNode.getChildCount(); i++){
      Node lChild = pNode.getChild(i);
      if(lChild instanceof Text) {
        ((ParentNode) pNode).removeChild(lChild);
        i--;
      }
    }

    //Insert the new text node as the first child of the target
    if(!XFUtil.isNull(pNewText)) {
      lElement.insertChild(pNewText, 0);
    }
  }
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Concatenates the text nodes of pNode and appends them to pStringBuffer. If pNode is a complex element and pDeep
 * is true, recurses down into pNode and concatenates all text nodes at all levels below and including pNode.
 * @param pNode The target node.
 * @param pStringBuffer The StringBuffer to append the result to.
 * @param pDeep If true, recurse down tree.
 */
private void _value(Node pNode, StringBuffer pStringBuffer, boolean pDeep) {
  for(int i=0; i < pNode.getChildCount(); i++){
    Node c = pNode.getChild(i);
    if(c instanceof Text){
      pStringBuffer.append(((Text)c).getValue());
    } else if (c instanceof Element && pDeep){
      _value(c, pStringBuffer, pDeep);
    }
  }
}
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Gets all child Nodes for pNode, wrapped as a DOMList.
 * @param pNode The target Node.
 * @return DOMList of all pNodes' child Nodes.
 */
public DOMList getChildNodes(Node pNode) {

  DOMList lDOMList = new DOMList();
  for(int i=0; i < pNode.getChildCount(); i++){
    lDOMList.add(new DOM(pNode.getChild(i)));
  }

  return lDOMList;
}
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Generate a String List of all the text nodes of pNode, in document order.
 * @param pNode The target node.
 * @param pDeep If true, recurse through child nodes adding their text nodes too.
 * @return A List of Strings representing text nodes.
 */
@Override
public final List<String> childTextNodesAsStringList(Node pNode, boolean pDeep){
  List<String> lList = new ArrayList<String>();
  for(int i=0; i < pNode.getChildCount(); i++){
    if(pNode.getChild(i) instanceof Text){
      lList.add(((Text)pNode.getChild(i)).getValue());
    }
    else if (pDeep) {
      lList.addAll(childTextNodesAsStringList(pNode.getChild(i), true));
    }
  }
  return lList;
}
 

import nu.xom.Node; //导入方法依赖的package包/类
/**
 * Returns true if the element contains any nodes
 */
public boolean hasChildNodes(Node pNode) {
  return (pNode.getChildCount() > 0);
}
 

import nu.xom.Node; //导入方法依赖的package包/类
private NodeInfo advance() {
	if (currNode == null) { // if includeSelf
		currNode = start.node;
		return start;
	}

	int i;
	do {
		i = 0;
		Node p = currNode;

		if (p.getChildCount() == 0 || moveToNextSibling) { // move to next sibling

			moveToNextSibling = false; // do it just once
			while (true) {
				// if we've reached the root we're done scanning
				p = currNode.getParent();
				if (p == null) return null;

				// Note: correct even if currNode is an attribute.
				// Performance is particularly good with the O(1) patch
				// for XOM's ParentNode.indexOf()
				i = currNode.getParent().indexOf(currNode) + 1;

				if (i < p.getChildCount()) {
					break; // break out of while(true) loop; move to next sibling
				}
				else { // reached last sibling; move up
					currNode = p;
					// if we've come all the way back to the start anchor we're done
					if (p == anchor) return null;
				}
			}
		}
		currNode = p.getChild(i);
	} while (!conforms(currNode));

	// note the null here: makeNodeWrapper(parent, ...) is fast, so it
	// doesn't really matter that we don't keep a link to it.
	// In fact, it makes objects more short lived, easing pressure on
	// the VM allocator and collector for tenured heaps.
	return makeWrapper(currNode, docWrapper, null, i);
}