1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 1999-2003 The Apache Software Foundation.  All rights 

  6.  * reserved.

  7.  *

  8.  * Redistribution and use in source and binary forms, with or without

  9.  * modification, are permitted provided that the following conditions

  10.  * are met:

  11.  *

  12.  * 1. Redistributions of source code must retain the above copyright

  13.  *    notice, this list of conditions and the following disclaimer. 

  14.  *

  15.  * 2. Redistributions in binary form must reproduce the above copyright

  16.  *    notice, this list of conditions and the following disclaimer in

  17.  *    the documentation and/or other materials provided with the

  18.  *    distribution.

  19.  *

  20.  * 3. The end-user documentation included with the redistribution,

  21.  *    if any, must include the following acknowledgment:  

  22.  *       "This product includes software developed by the

  23.  *        Apache Software Foundation (http://www.apache.org/)."

  24.  *    Alternately, this acknowledgment may appear in the software itself,

  25.  *    if and wherever such third-party acknowledgments normally appear.

  26.  *

  27.  * 4. The names "Xerces" and "Apache Software Foundation" must

  28.  *    not be used to endorse or promote products derived from this

  29.  *    software without prior written permission. For written 

  30.  *    permission, please contact apache@apache.org.

  31.  *

  32.  * 5. Products derived from this software may not be called "Apache",

  33.  *    nor may "Apache" appear in their name, without prior written

  34.  *    permission of the Apache Software Foundation.

  35.  *

  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  47.  * SUCH DAMAGE.

  48.  * ====================================================================

  49.  *

  50.  * This software consists of voluntary contributions made by many

  51.  * individuals on behalf of the Apache Software Foundation and was

  52.  * originally based on software copyright (c) 1999, International

  53.  * Business Machines, Inc., http://www.apache.org.  For more

  54.  * information on the Apache Software Foundation, please see

  55.  * <http://www.apache.org/>.

  56.  */

  57. 

  58. package com.sun.org.apache.xerces.internal.dom;

  59. 

  60. import org.w3c.dom.DocumentFragment;

  61. import org.w3c.dom.Node;

  62. import org.w3c.dom.Text;

  63. 

  64. /**

  65.  * DocumentFragment is a "lightweight" or "minimal" Document

  66.  * object. It is very common to want to be able to extract a portion

  67.  * of a document's tree or to create a new fragment of a

  68.  * document. Imagine implementing a user command like cut or

  69.  * rearranging a document by moving fragments around. It is desirable

  70.  * to have an object which can hold such fragments and it is quite

  71.  * natural to use a Node for this purpose. While it is true that a

  72.  * Document object could fulfil this role, a Document object can

  73.  * potentially be a heavyweight object, depending on the underlying

  74.  * implementation... and in DOM Level 1, nodes aren't allowed to cross

  75.  * Document boundaries anyway. What is really needed for this is a

  76.  * very lightweight object.  DocumentFragment is such an object.

  77.  * <P>

  78.  * Furthermore, various operations -- such as inserting nodes as

  79.  * children of another Node -- may take DocumentFragment objects as

  80.  * arguments; this results in all the child nodes of the

  81.  * DocumentFragment being moved to the child list of this node.

  82.  * <P>

  83.  * The children of a DocumentFragment node are zero or more nodes

  84.  * representing the tops of any sub-trees defining the structure of

  85.  * the document.  DocumentFragment do not need to be well-formed XML

  86.  * documents (although they do need to follow the rules imposed upon

  87.  * well-formed XML parsed entities, which can have multiple top

  88.  * nodes). For example, a DocumentFragment might have only one child

  89.  * and that child node could be a Text node. Such a structure model

  90.  * represents neither an HTML document nor a well-formed XML document.

  91.  * <P>

  92.  * When a DocumentFragment is inserted into a Document (or indeed any

  93.  * other Node that may take children) the children of the

  94.  * DocumentFragment and not the DocumentFragment itself are inserted

  95.  * into the Node. This makes the DocumentFragment very useful when the

  96.  * user wishes to create nodes that are siblings; the DocumentFragment

  97.  * acts as the parent of these nodes so that the user can use the

  98.  * standard methods from the Node interface, such as insertBefore()

  99.  * and appendChild().

  100.  *

  101.  * @version $Id: DocumentFragmentImpl.java,v 1.11 2003/02/11 22:20:33 neilg Exp $

  102.  * @since  PR-DOM-Level-1-19980818.

  103.  */

  104. public class DocumentFragmentImpl 

  105.     extends ParentNode

  106.     implements DocumentFragment {

  107. 

  108.     //

  109.     // Constants

  110.     //

  111. 

  112.     /** Serialization version. */

  113.     static final long serialVersionUID = -7596449967279236746L;

  114.     

  115.     //

  116.     // Constructors

  117.     //

  118. 

  119.     /** Factory constructor. */

  120.     public DocumentFragmentImpl(CoreDocumentImpl ownerDoc) {

  121.         super(ownerDoc);

  122.     }  

  123.   

  124.     /** Constructor for serialization. */

  125.     public DocumentFragmentImpl() {}

  126. 

  127.     //

  128.     // Node methods

  129.     //

  130. 

  131.     /** 

  132.      * A short integer indicating what type of node this is. The named

  133.      * constants for this value are defined in the org.w3c.dom.Node interface.

  134.      */

  135.     public short getNodeType() {

  136.         return Node.DOCUMENT_FRAGMENT_NODE;

  137.     }

  138. 

  139.     /** Returns the node name. */

  140.     public String getNodeName() {

  141.         return "#document-fragment";

  142.     }

  143.     

  144.     /**

  145.      * Override default behavior to call normalize() on this Node's

  146.      * children. It is up to implementors or Node to override normalize()

  147.      * to take action.

  148.      */

  149.     public void normalize() {

  150.         // No need to normalize if already normalized.

  151.         if (isNormalized()) {

  152.             return;

  153.         }

  154.         if (needsSyncChildren()) {

  155.             synchronizeChildren();

  156.         }

  157.         ChildNode kid, next;

  158. 

  159.         for (kid = firstChild; kid != null; kid = next) {

  160.             next = kid.nextSibling;

  161. 

  162.             // If kid is a text node, we need to check for one of two

  163.             // conditions:

  164.             //   1) There is an adjacent text node

  165.             //   2) There is no adjacent text node, but kid is

  166.             //      an empty text node.

  167.             if ( kid.getNodeType() == Node.TEXT_NODE )

  168.             {

  169.                 // If an adjacent text node, merge it with kid

  170.                 if ( next!=null && next.getNodeType() == Node.TEXT_NODE )

  171.                 {

  172.                     ((Text)kid).appendData(next.getNodeValue());

  173.                     removeChild( next );

  174.                     next = kid; // Don't advance; there might be another.

  175.                 }

  176.                 else

  177.                 {

  178.                     // If kid is empty, remove it

  179.                     if ( kid.getNodeValue().length()==0 )

  180.                         removeChild( kid );

  181.                 }

  182.             }

  183. 

  184.             kid.normalize();

  185.         }

  186. 

  187.         isNormalized(true);

  188.     }

  189. 

  190. } // class DocumentFragmentImpl