Save This Page
1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Copyright 1999-2004 The Apache Software Foundation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.xerces.internal.dom;
22
23 import org.w3c.dom.DocumentFragment;
24 import org.w3c.dom.Node;
25 import org.w3c.dom.Text;
26
27 /**
28 * DocumentFragment is a "lightweight" or "minimal" Document
29 * object. It is very common to want to be able to extract a portion
30 * of a document's tree or to create a new fragment of a
31 * document. Imagine implementing a user command like cut or
32 * rearranging a document by moving fragments around. It is desirable
33 * to have an object which can hold such fragments and it is quite
34 * natural to use a Node for this purpose. While it is true that a
35 * Document object could fulfil this role, a Document object can
36 * potentially be a heavyweight object, depending on the underlying
37 * implementation... and in DOM Level 1, nodes aren't allowed to cross
38 * Document boundaries anyway. What is really needed for this is a
39 * very lightweight object. DocumentFragment is such an object.
40 * <P>
41 * Furthermore, various operations -- such as inserting nodes as
42 * children of another Node -- may take DocumentFragment objects as
43 * arguments; this results in all the child nodes of the
44 * DocumentFragment being moved to the child list of this node.
45 * <P>
46 * The children of a DocumentFragment node are zero or more nodes
47 * representing the tops of any sub-trees defining the structure of
48 * the document. DocumentFragment do not need to be well-formed XML
49 * documents (although they do need to follow the rules imposed upon
50 * well-formed XML parsed entities, which can have multiple top
51 * nodes). For example, a DocumentFragment might have only one child
52 * and that child node could be a Text node. Such a structure model
53 * represents neither an HTML document nor a well-formed XML document.
54 * <P>
55 * When a DocumentFragment is inserted into a Document (or indeed any
56 * other Node that may take children) the children of the
57 * DocumentFragment and not the DocumentFragment itself are inserted
58 * into the Node. This makes the DocumentFragment very useful when the
59 * user wishes to create nodes that are siblings; the DocumentFragment
60 * acts as the parent of these nodes so that the user can use the
61 * standard methods from the Node interface, such as insertBefore()
62 * and appendChild().
63 *
64 * @xerces.internal
65 *
66 * @since PR-DOM-Level-1-19980818.
67 */
68 public class DocumentFragmentImpl
69 extends ParentNode
70 implements DocumentFragment {
71
72 //
73 // Constants
74 //
75
76 /** Serialization version. */
77 static final long serialVersionUID = -7596449967279236746L;
78
79 //
80 // Constructors
81 //
82
83 /** Factory constructor. */
84 public DocumentFragmentImpl(CoreDocumentImpl ownerDoc) {
85 super(ownerDoc);
86 }
87
88 /** Constructor for serialization. */
89 public DocumentFragmentImpl() {}
90
91 //
92 // Node methods
93 //
94
95 /**
96 * A short integer indicating what type of node this is. The named
97 * constants for this value are defined in the org.w3c.dom.Node interface.
98 */
99 public short getNodeType() {
100 return Node.DOCUMENT_FRAGMENT_NODE;
101 }
102
103 /** Returns the node name. */
104 public String getNodeName() {
105 return "#document-fragment";
106 }
107
108 /**
109 * Override default behavior to call normalize() on this Node's
110 * children. It is up to implementors or Node to override normalize()
111 * to take action.
112 */
113 public void normalize() {
114 // No need to normalize if already normalized.
115 if (isNormalized()) {
116 return;
117 }
118 if (needsSyncChildren()) {
119 synchronizeChildren();
120 }
121 ChildNode kid, next;
122
123 for (kid = firstChild; kid != null; kid = next) {
124 next = kid.nextSibling;
125
126 // If kid is a text node, we need to check for one of two
127 // conditions:
128 // 1) There is an adjacent text node
129 // 2) There is no adjacent text node, but kid is
130 // an empty text node.
131 if ( kid.getNodeType() == Node.TEXT_NODE )
132 {
133 // If an adjacent text node, merge it with kid
134 if ( next!=null && next.getNodeType() == Node.TEXT_NODE )
135 {
136 ((Text)kid).appendData(next.getNodeValue());
137 removeChild( next );
138 next = kid; // Don't advance; there might be another.
139 }
140 else
141 {
142 // If kid is empty, remove it
143 if ( kid.getNodeValue() == null || kid.getNodeValue().length() == 0 ) {
144 removeChild( kid );
145 }
146 }
147 }
148
149 kid.normalize();
150 }
151
152 isNormalized(true);
153 }
154
155 } // class DocumentFragmentImpl