KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > org > apache > xerces > internal > dom > DocumentFragmentImpl


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 JavaDoc;
61 import org.w3c.dom.Node JavaDoc;
62 import org.w3c.dom.Text JavaDoc;
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 JavaDoc {
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 JavaDoc 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 JavaDoc)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
191
Popular Tags