Save This Page
1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Copyright 1999-2002,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 com.sun.org.apache.xerces.internal.util.URI;
24 import org.w3c.dom.DocumentType;
25 import org.w3c.dom.EntityReference;
26 import org.w3c.dom.NamedNodeMap;
27 import org.w3c.dom.Node;
28
29 /**
30 * EntityReference models the XML &entityname; syntax, when used for
31 * entities defined by the DOM. Entities hardcoded into XML, such as
32 * character entities, should instead have been translated into text
33 * by the code which generated the DOM tree.
34 * <P>
35 * An XML processor has the alternative of fully expanding Entities
36 * into the normal document tree. If it does so, no EntityReference nodes
37 * will appear.
38 * <P>
39 * Similarly, non-validating XML processors are not required to read
40 * or process entity declarations made in the external subset or
41 * declared in external parameter entities. Hence, some applications
42 * may not make the replacement value available for Parsed Entities
43 * of these types.
44 * <P>
45 * EntityReference behaves as a read-only node, and the children of
46 * the EntityReference (which reflect those of the Entity, and should
47 * also be read-only) give its replacement value, if any. They are
48 * supposed to automagically stay in synch if the DocumentType is
49 * updated with new values for the Entity.
50 * <P>
51 * The defined behavior makes efficient storage difficult for the DOM
52 * implementor. We can't just look aside to the Entity's definition
53 * in the DocumentType since those nodes have the wrong parent (unless
54 * we can come up with a clever "imaginary parent" mechanism). We
55 * must at least appear to clone those children... which raises the
56 * issue of keeping the reference synchronized with its parent.
57 * This leads me back to the "cached image of centrally defined data"
58 * solution, much as I dislike it.
59 * <P>
60 * For now I have decided, since REC-DOM-Level-1-19980818 doesn't
61 * cover this in much detail, that synchronization doesn't have to be
62 * considered while the user is deep in the tree. That is, if you're
63 * looking within one of the EntityReferennce's children and the Entity
64 * changes, you won't be informed; instead, you will continue to access
65 * the same object -- which may or may not still be part of the tree.
66 * This is the same behavior that obtains elsewhere in the DOM if the
67 * subtree you're looking at is deleted from its parent, so it's
68 * acceptable here. (If it really bothers folks, we could set things
69 * up so deleted subtrees are walked and marked invalid, but that's
70 * not part of the DOM's defined behavior.)
71 * <P>
72 * As a result, only the EntityReference itself has to be aware of
73 * changes in the Entity. And it can take advantage of the same
74 * structure-change-monitoring code I implemented to support
75 * DeepNodeList.
76 *
77 * @xerces.internal
78 *
79 * @author Arnaud Le Hors, IBM
80 * @author Joe Kesselman, IBM
81 * @author Andy Clark, IBM
82 * @author Ralf Pfeiffer, IBM
83 * @since PR-DOM-Level-1-19980818.
84 */
85 public class EntityReferenceImpl
86 extends ParentNode
87 implements EntityReference {
88
89 //
90 // Constants
91 //
92
93 /** Serialization version. */
94 static final long serialVersionUID = -7381452955687102062L;
95
96 //
97 // Data
98 //
99
100 /** Name of Entity referenced */
101 protected String name;
102 /** Base URI*/
103 protected String baseURI;
104
105
106 /** Entity changes. */
107 //protected int entityChanges = -1;
108
109 /** Enable synchronize. */
110 //protected boolean fEnableSynchronize = false;
111
112 //
113 // Constructors
114 //
115
116 /** Factory constructor. */
117 public EntityReferenceImpl(CoreDocumentImpl ownerDoc, String name) {
118 super(ownerDoc);
119 this.name = name;
120 isReadOnly(true);
121 needsSyncChildren(true);
122 }
123
124 //
125 // Node methods
126 //
127
128 /**
129 * A short integer indicating what type of node this is. The named
130 * constants for this value are defined in the org.w3c.dom.Node interface.
131 */
132 public short getNodeType() {
133 return Node.ENTITY_REFERENCE_NODE;
134 }
135
136 /**
137 * Returns the name of the entity referenced
138 */
139 public String getNodeName() {
140 if (needsSyncData()) {
141 synchronizeData();
142 }
143 return name;
144 }
145
146 /** Clone node. */
147 public Node cloneNode(boolean deep) {
148 EntityReferenceImpl er = (EntityReferenceImpl)super.cloneNode(deep);
149 er.setReadOnly(true, deep);
150 return er;
151 }
152
153 /**
154 * Returns the absolute base URI of this node or null if the implementation
155 * wasn't able to obtain an absolute URI. Note: If the URI is malformed, a
156 * null is returned.
157 *
158 * @return The absolute base URI of this node or null.
159 * @since DOM Level 3
160 */
161 public String getBaseURI() {
162 if (needsSyncData()) {
163 synchronizeData();
164 }
165 if (baseURI == null) {
166 DocumentType doctype;
167 NamedNodeMap entities;
168 EntityImpl entDef;
169 if (null != (doctype = getOwnerDocument().getDoctype()) &&
170 null != (entities = doctype.getEntities())) {
171
172 entDef = (EntityImpl)entities.getNamedItem(getNodeName());
173 if (entDef !=null) {
174 return entDef.getBaseURI();
175 }
176 }
177 } else if (baseURI != null && baseURI.length() != 0 ) {// attribute value is always empty string
178 try {
179 return new URI(baseURI).toString();
180 }
181 catch (com.sun.org.apache.xerces.internal.util.URI.MalformedURIException e){
182 // REVISIT: what should happen in this case?
183 return null;
184 }
185 }
186 return baseURI;
187 }
188
189
190 /** NON-DOM: set base uri*/
191 public void setBaseURI(String uri){
192 if (needsSyncData()) {
193 synchronizeData();
194 }
195 baseURI = uri;
196 }
197
198 /**
199 * NON-DOM: compute string representation of the entity reference.
200 * This method is used to retrieve a string value for an attribute node that has child nodes.
201 * @return String representing a value of this entity ref. or
202 * null if any node other than EntityReference, Text is encountered
203 * during computation
204 */
205 protected String getEntityRefValue (){
206 if (needsSyncChildren()){
207 synchronizeChildren();
208 }
209
210 String value = "";
211 if (firstChild != null){
212 if (firstChild.getNodeType() == Node.ENTITY_REFERENCE_NODE){
213 value = ((EntityReferenceImpl)firstChild).getEntityRefValue();
214 }
215 else if (firstChild.getNodeType() == Node.TEXT_NODE){
216 value = firstChild.getNodeValue();
217 }
218 else {
219 // invalid to have other types of nodes in attr value
220 return null;
221 }
222
223 if (firstChild.nextSibling == null){
224 return value;
225 }
226 else {
227 StringBuffer buff = new StringBuffer(value);
228 ChildNode next = firstChild.nextSibling;
229 while (next != null){
230
231 if (next.getNodeType() == Node.ENTITY_REFERENCE_NODE){
232 value = ((EntityReferenceImpl)next).getEntityRefValue();
233 }
234 else if (next.getNodeType() == Node.TEXT_NODE){
235 value = next.getNodeValue();
236 }
237 else {
238 // invalid to have other types of nodes in attr value
239 return null;
240 }
241 buff.append(value);
242 next = next.nextSibling;
243
244 }
245 return buff.toString();
246 }
247 }
248 return "";
249 }
250
251 /**
252 * EntityReference's children are a reflection of those defined in the
253 * named Entity. This method creates them if they haven't been created yet.
254 * This doesn't support editing the Entity though, since this only called
255 * once for all.
256 */
257 protected void synchronizeChildren() {
258 // no need to synchronize again
259 needsSyncChildren(false);
260
261 DocumentType doctype;
262 NamedNodeMap entities;
263 EntityImpl entDef;
264 if (null != (doctype = getOwnerDocument().getDoctype()) &&
265 null != (entities = doctype.getEntities())) {
266
267 entDef = (EntityImpl)entities.getNamedItem(getNodeName());
268
269 // No Entity by this name, stop here.
270 if (entDef == null)
271 return;
272
273 // If entity's definition exists, clone its kids
274 isReadOnly(false);
275 for (Node defkid = entDef.getFirstChild();
276 defkid != null;
277 defkid = defkid.getNextSibling()) {
278 Node newkid = defkid.cloneNode(true);
279 insertBefore(newkid, null);
280 }
281 setReadOnly(true, true);
282 }
283 }
284
285
286 /**
287 * NON-DOM: sets the node and its children value.
288 * <P>
289 * Note: make sure that entity reference and its kids could be set readonly.
290 */
291 public void setReadOnly(boolean readOnly, boolean deep) {
292
293 if (needsSyncData()) {
294 synchronizeData();
295 }
296 if (deep) {
297
298 if (needsSyncChildren()) {
299 synchronizeChildren();
300 }
301 // Recursively set kids
302 for (ChildNode mykid = firstChild;
303 mykid != null;
304 mykid = mykid.nextSibling) {
305
306 mykid.setReadOnly(readOnly,true);
307
308 }
309 }
310 isReadOnly(readOnly);
311 } // setReadOnly(boolean,boolean)
312
313
314 /**
315 * Enable the synchronize method which may do cloning. This method is enabled
316 * when the parser is done with an EntityReference.
317 /***
318 // revisit: enable editing of Entity
319 public void enableSynchronize(boolean enableSynchronize) {
320 fEnableSynchronize= enableSynchronize;
321 }
322 /***/
323
324 /**
325 * EntityReference's children are a reflection of those defined in the
326 * named Entity. This method updates them if the Entity is changed.
327 * <P>
328 * It is unclear what the least-cost resynch mechanism is.
329 * If we expect the kids to be shallow, and/or expect changes
330 * to the Entity contents to be rare, wiping them all out
331 * and recloning is simplest.
332 * <P>
333 * If we expect them to be deep,
334 * it might be better to first decide which kids (if any)
335 * persist, and keep the ones (if any) that are unchanged
336 * rather than doing all the work of cloning them again.
337 * But that latter gets into having to convolve the two child lists,
338 * insert new information in the right order (and possibly reorder
339 * the existing kids), and a few other complexities that I really
340 * don't want to deal with in this implementation.
341 * <P>
342 * Note that if we decide that we need to update the EntityReference's
343 * contents, we have to turn off the readOnly flag temporarily to do so.
344 * When we get around to adding multitasking support, this whole method
345 * should probably be an atomic operation.
346 *
347 * @see DocumentTypeImpl
348 * @see EntityImpl
349 */
350 // The Xerces parser invokes callbacks for startEnityReference
351 // the parsed value of the entity EACH TIME, so it is actually
352 // easier to create the nodes through the callbacks rather than
353 // clone the Entity.
354 /***
355 // revisit: enable editing of Entity
356 private void synchronize() {
357 if (!fEnableSynchronize) {
358 return;
359 }
360 DocumentType doctype;
361 NamedNodeMap entities;
362 EntityImpl entDef;
363 if (null != (doctype = getOwnerDocument().getDoctype()) &&
364 null != (entities = doctype.getEntities())) {
365
366 entDef = (EntityImpl)entities.getNamedItem(getNodeName());
367
368 // No Entity by this name. If we had a change count, reset it.
369 if(null==entDef)
370 entityChanges=-1;
371
372 // If no kids availalble, wipe any pre-existing children.
373 // (See discussion above.)
374 // Note that we have to use the superclass to avoid recursion
375 // through Synchronize.
376 readOnly=false;
377 if(null==entDef || !entDef.hasChildNodes())
378 for(Node kid=super.getFirstChild();
379 kid!=null;
380 kid=super.getFirstChild())
381 removeChild(kid);
382
383 // If entity's definition changed, clone its kids
384 // (See discussion above.)
385 if(null!=entDef && entDef.changes!=entityChanges) {
386 for(Node defkid=entDef.getFirstChild();
387 defkid!=null;
388 defkid=defkid.getNextSibling()) {
389
390 NodeImpl newkid=(NodeImpl) defkid.cloneNode(true);
391 newkid.setReadOnly(true,true);
392 insertBefore(newkid,null);
393 }
394 entityChanges=entDef.changes;
395 }
396 readOnly=true;
397 }
398 }
399 /***/
400
401
402 } // class EntityReferenceImpl