| /* |
| * reserved comment block |
| * DO NOT REMOVE OR ALTER! |
| */ |
| /* |
| * 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. |
| */ |
| |
| package com.sun.org.apache.xerces.internal.dom; |
| |
| import com.sun.org.apache.xerces.internal.util.URI; |
| import org.w3c.dom.DocumentType; |
| import org.w3c.dom.EntityReference; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| |
| /** |
| * EntityReference models the XML &entityname; syntax, when used for |
| * entities defined by the DOM. Entities hardcoded into XML, such as |
| * character entities, should instead have been translated into text |
| * by the code which generated the DOM tree. |
| * <P> |
| * An XML processor has the alternative of fully expanding Entities |
| * into the normal document tree. If it does so, no EntityReference nodes |
| * will appear. |
| * <P> |
| * Similarly, non-validating XML processors are not required to read |
| * or process entity declarations made in the external subset or |
| * declared in external parameter entities. Hence, some applications |
| * may not make the replacement value available for Parsed Entities |
| * of these types. |
| * <P> |
| * EntityReference behaves as a read-only node, and the children of |
| * the EntityReference (which reflect those of the Entity, and should |
| * also be read-only) give its replacement value, if any. They are |
| * supposed to automagically stay in synch if the DocumentType is |
| * updated with new values for the Entity. |
| * <P> |
| * The defined behavior makes efficient storage difficult for the DOM |
| * implementor. We can't just look aside to the Entity's definition |
| * in the DocumentType since those nodes have the wrong parent (unless |
| * we can come up with a clever "imaginary parent" mechanism). We |
| * must at least appear to clone those children... which raises the |
| * issue of keeping the reference synchronized with its parent. |
| * This leads me back to the "cached image of centrally defined data" |
| * solution, much as I dislike it. |
| * <P> |
| * For now I have decided, since REC-DOM-Level-1-19980818 doesn't |
| * cover this in much detail, that synchronization doesn't have to be |
| * considered while the user is deep in the tree. That is, if you're |
| * looking within one of the EntityReferennce's children and the Entity |
| * changes, you won't be informed; instead, you will continue to access |
| * the same object -- which may or may not still be part of the tree. |
| * This is the same behavior that obtains elsewhere in the DOM if the |
| * subtree you're looking at is deleted from its parent, so it's |
| * acceptable here. (If it really bothers folks, we could set things |
| * up so deleted subtrees are walked and marked invalid, but that's |
| * not part of the DOM's defined behavior.) |
| * <P> |
| * As a result, only the EntityReference itself has to be aware of |
| * changes in the Entity. And it can take advantage of the same |
| * structure-change-monitoring code I implemented to support |
| * DeepNodeList. |
| * |
| * @xerces.internal |
| * |
| * @author Arnaud Le Hors, IBM |
| * @author Joe Kesselman, IBM |
| * @author Andy Clark, IBM |
| * @author Ralf Pfeiffer, IBM |
| * @since PR-DOM-Level-1-19980818. |
| */ |
| public class EntityReferenceImpl |
| extends ParentNode |
| implements EntityReference { |
| |
| // |
| // Constants |
| // |
| |
| /** Serialization version. */ |
| static final long serialVersionUID = -7381452955687102062L; |
| |
| // |
| // Data |
| // |
| |
| /** Name of Entity referenced */ |
| protected String name; |
| /** Base URI*/ |
| protected String baseURI; |
| |
| |
| /** Entity changes. */ |
| //protected int entityChanges = -1; |
| |
| /** Enable synchronize. */ |
| //protected boolean fEnableSynchronize = false; |
| |
| // |
| // Constructors |
| // |
| |
| /** Factory constructor. */ |
| public EntityReferenceImpl(CoreDocumentImpl ownerDoc, String name) { |
| super(ownerDoc); |
| this.name = name; |
| isReadOnly(true); |
| needsSyncChildren(true); |
| } |
| |
| // |
| // Node methods |
| // |
| |
| /** |
| * A short integer indicating what type of node this is. The named |
| * constants for this value are defined in the org.w3c.dom.Node interface. |
| */ |
| public short getNodeType() { |
| return Node.ENTITY_REFERENCE_NODE; |
| } |
| |
| /** |
| * Returns the name of the entity referenced |
| */ |
| public String getNodeName() { |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| return name; |
| } |
| |
| /** Clone node. */ |
| public Node cloneNode(boolean deep) { |
| EntityReferenceImpl er = (EntityReferenceImpl)super.cloneNode(deep); |
| er.setReadOnly(true, deep); |
| return er; |
| } |
| |
| /** |
| * Returns the absolute base URI of this node or null if the implementation |
| * wasn't able to obtain an absolute URI. Note: If the URI is malformed, a |
| * null is returned. |
| * |
| * @return The absolute base URI of this node or null. |
| * @since DOM Level 3 |
| */ |
| public String getBaseURI() { |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| if (baseURI == null) { |
| DocumentType doctype; |
| NamedNodeMap entities; |
| EntityImpl entDef; |
| if (null != (doctype = getOwnerDocument().getDoctype()) && |
| null != (entities = doctype.getEntities())) { |
| |
| entDef = (EntityImpl)entities.getNamedItem(getNodeName()); |
| if (entDef !=null) { |
| return entDef.getBaseURI(); |
| } |
| } |
| } else if (baseURI != null && baseURI.length() != 0 ) {// attribute value is always empty string |
| try { |
| return new URI(baseURI).toString(); |
| } |
| catch (com.sun.org.apache.xerces.internal.util.URI.MalformedURIException e){ |
| // REVISIT: what should happen in this case? |
| return null; |
| } |
| } |
| return baseURI; |
| } |
| |
| |
| /** NON-DOM: set base uri*/ |
| public void setBaseURI(String uri){ |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| baseURI = uri; |
| } |
| |
| /** |
| * NON-DOM: compute string representation of the entity reference. |
| * This method is used to retrieve a string value for an attribute node that has child nodes. |
| * @return String representing a value of this entity ref. or |
| * null if any node other than EntityReference, Text is encountered |
| * during computation |
| */ |
| protected String getEntityRefValue (){ |
| if (needsSyncChildren()){ |
| synchronizeChildren(); |
| } |
| |
| String value = ""; |
| if (firstChild != null){ |
| if (firstChild.getNodeType() == Node.ENTITY_REFERENCE_NODE){ |
| value = ((EntityReferenceImpl)firstChild).getEntityRefValue(); |
| } |
| else if (firstChild.getNodeType() == Node.TEXT_NODE){ |
| value = firstChild.getNodeValue(); |
| } |
| else { |
| // invalid to have other types of nodes in attr value |
| return null; |
| } |
| |
| if (firstChild.nextSibling == null){ |
| return value; |
| } |
| else { |
| StringBuffer buff = new StringBuffer(value); |
| ChildNode next = firstChild.nextSibling; |
| while (next != null){ |
| |
| if (next.getNodeType() == Node.ENTITY_REFERENCE_NODE){ |
| value = ((EntityReferenceImpl)next).getEntityRefValue(); |
| } |
| else if (next.getNodeType() == Node.TEXT_NODE){ |
| value = next.getNodeValue(); |
| } |
| else { |
| // invalid to have other types of nodes in attr value |
| return null; |
| } |
| buff.append(value); |
| next = next.nextSibling; |
| |
| } |
| return buff.toString(); |
| } |
| } |
| return ""; |
| } |
| |
| /** |
| * EntityReference's children are a reflection of those defined in the |
| * named Entity. This method creates them if they haven't been created yet. |
| * This doesn't support editing the Entity though, since this only called |
| * once for all. |
| */ |
| protected void synchronizeChildren() { |
| // no need to synchronize again |
| needsSyncChildren(false); |
| |
| DocumentType doctype; |
| NamedNodeMap entities; |
| EntityImpl entDef; |
| if (null != (doctype = getOwnerDocument().getDoctype()) && |
| null != (entities = doctype.getEntities())) { |
| |
| entDef = (EntityImpl)entities.getNamedItem(getNodeName()); |
| |
| // No Entity by this name, stop here. |
| if (entDef == null) |
| return; |
| |
| // If entity's definition exists, clone its kids |
| isReadOnly(false); |
| for (Node defkid = entDef.getFirstChild(); |
| defkid != null; |
| defkid = defkid.getNextSibling()) { |
| Node newkid = defkid.cloneNode(true); |
| insertBefore(newkid, null); |
| } |
| setReadOnly(true, true); |
| } |
| } |
| |
| |
| /** |
| * NON-DOM: sets the node and its children value. |
| * <P> |
| * Note: make sure that entity reference and its kids could be set readonly. |
| */ |
| public void setReadOnly(boolean readOnly, boolean deep) { |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| if (deep) { |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| // Recursively set kids |
| for (ChildNode mykid = firstChild; |
| mykid != null; |
| mykid = mykid.nextSibling) { |
| |
| mykid.setReadOnly(readOnly,true); |
| |
| } |
| } |
| isReadOnly(readOnly); |
| } // setReadOnly(boolean,boolean) |
| |
| |
| /** |
| * Enable the synchronize method which may do cloning. This method is enabled |
| * when the parser is done with an EntityReference. |
| /*** |
| // revisit: enable editing of Entity |
| public void enableSynchronize(boolean enableSynchronize) { |
| fEnableSynchronize= enableSynchronize; |
| } |
| /***/ |
| |
| /** |
| * EntityReference's children are a reflection of those defined in the |
| * named Entity. This method updates them if the Entity is changed. |
| * <P> |
| * It is unclear what the least-cost resynch mechanism is. |
| * If we expect the kids to be shallow, and/or expect changes |
| * to the Entity contents to be rare, wiping them all out |
| * and recloning is simplest. |
| * <P> |
| * If we expect them to be deep, |
| * it might be better to first decide which kids (if any) |
| * persist, and keep the ones (if any) that are unchanged |
| * rather than doing all the work of cloning them again. |
| * But that latter gets into having to convolve the two child lists, |
| * insert new information in the right order (and possibly reorder |
| * the existing kids), and a few other complexities that I really |
| * don't want to deal with in this implementation. |
| * <P> |
| * Note that if we decide that we need to update the EntityReference's |
| * contents, we have to turn off the readOnly flag temporarily to do so. |
| * When we get around to adding multitasking support, this whole method |
| * should probably be an atomic operation. |
| * |
| * @see DocumentTypeImpl |
| * @see EntityImpl |
| */ |
| // The Xerces parser invokes callbacks for startEntityReference |
| // the parsed value of the entity EACH TIME, so it is actually |
| // easier to create the nodes through the callbacks rather than |
| // clone the Entity. |
| /*** |
| // revisit: enable editing of Entity |
| private void synchronize() { |
| if (!fEnableSynchronize) { |
| return; |
| } |
| DocumentType doctype; |
| NamedNodeMap entities; |
| EntityImpl entDef; |
| if (null != (doctype = getOwnerDocument().getDoctype()) && |
| null != (entities = doctype.getEntities())) { |
| |
| entDef = (EntityImpl)entities.getNamedItem(getNodeName()); |
| |
| // No Entity by this name. If we had a change count, reset it. |
| if(null==entDef) |
| entityChanges=-1; |
| |
| // If no kids availalble, wipe any pre-existing children. |
| // (See discussion above.) |
| // Note that we have to use the superclass to avoid recursion |
| // through Synchronize. |
| readOnly=false; |
| if(null==entDef || !entDef.hasChildNodes()) |
| for(Node kid=super.getFirstChild(); |
| kid!=null; |
| kid=super.getFirstChild()) |
| removeChild(kid); |
| |
| // If entity's definition changed, clone its kids |
| // (See discussion above.) |
| if(null!=entDef && entDef.changes!=entityChanges) { |
| for(Node defkid=entDef.getFirstChild(); |
| defkid!=null; |
| defkid=defkid.getNextSibling()) { |
| |
| NodeImpl newkid=(NodeImpl) defkid.cloneNode(true); |
| newkid.setReadOnly(true,true); |
| insertBefore(newkid,null); |
| } |
| entityChanges=entDef.changes; |
| } |
| readOnly=true; |
| } |
| } |
| /***/ |
| |
| |
| } // class EntityReferenceImpl |
