Copies the source tree into the specified place in a destination tree. : Node « XML « Java Tutorial

1. Java Tutorial
2. XML
3. Node

import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

import com.sun.org.apache.xerces.internal.dom.AttrImpl;
import com.sun.org.apache.xerces.internal.dom.DocumentImpl;

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

public class Main {
  
  /**
   * Copies the source tree into the specified place in a destination
   * tree. The source node and its children are appended as children
   * of the destination node.
   * <p>
   * <em>Note:</em> This is an iterative implementation.
   */
  public static void copyInto(Node src, Node dest) throws DOMException {
      
      // get node factory
      Document factory = dest.getOwnerDocument();
      boolean domimpl = factory instanceof DocumentImpl;
      
      // placement variables
      Node start  = src;
      Node parent = src;
      Node place  = src;
      
      // traverse source tree
      while (place != null) {
          
          // copy this node
          Node node = null;
          int  type = place.getNodeType();
          switch (type) {
          case Node.CDATA_SECTION_NODE: {
              node = factory.createCDATASection(place.getNodeValue());
              break;
          }
          case Node.COMMENT_NODE: {
              node = factory.createComment(place.getNodeValue());
              break;
          }
          case Node.ELEMENT_NODE: {
              Element element = factory.createElement(place.getNodeName());
              node = element;
              NamedNodeMap attrs  = place.getAttributes();
              int attrCount = attrs.getLength();
              for (int i = 0; i < attrCount; i++) {
                  Attr attr = (Attr)attrs.item(i);
                  String attrName = attr.getNodeName();
                  String attrValue = attr.getNodeValue();
                  element.setAttribute(attrName, attrValue);
                  if (domimpl && !attr.getSpecified()) {
                      ((AttrImpl)element.getAttributeNode(attrName)).setSpecified(false);
                  }
              }
              break;
          }
          case Node.ENTITY_REFERENCE_NODE: {
              node = factory.createEntityReference(place.getNodeName());
              break;
          }
          case Node.PROCESSING_INSTRUCTION_NODE: {
              node = factory.createProcessingInstruction(place.getNodeName(),
                      place.getNodeValue());
              break;
          }
          case Node.TEXT_NODE: {
              node = factory.createTextNode(place.getNodeValue());
              break;
          }
          default: {
              throw new IllegalArgumentException("can't copy node type, "+
                      type+" ("+
                      node.getNodeName()+')');
          }
          }
          dest.appendChild(node);
          
          // iterate over children
          if (place.hasChildNodes()) {
              parent = place;
              place  = place.getFirstChild();
              dest   = node;
          }
          
          // advance
          else {
              place = place.getNextSibling();
              while (place == null && parent != start) {
                  place  = parent.getNextSibling();
                  parent = parent.getParentNode();
                  dest   = dest.getParentNode();
              }
          }
          
      }
      
  } // copyInto(Node,Node)
}