| /* |
| * reserved comment block |
| * DO NOT REMOVE OR ALTER! |
| */ |
| /* |
| * Copyright 1999-2004 The Apache Software Foundation. |
| * |
| * Licensed 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 java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| |
| import org.w3c.dom.TypeInfo; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.Text; |
| |
| /** |
| * Attribute represents an XML-style attribute of an |
| * Element. Typically, the allowable values are controlled by its |
| * declaration in the Document Type Definition (DTD) governing this |
| * kind of document. |
| * <P> |
| * If the attribute has not been explicitly assigned a value, but has |
| * been declared in the DTD, it will exist and have that default. Only |
| * if neither the document nor the DTD specifies a value will the |
| * Attribute really be considered absent and have no value; in that |
| * case, querying the attribute will return null. |
| * <P> |
| * Attributes may have multiple children that contain their data. (XML |
| * allows attributes to contain entity references, and tokenized |
| * attribute types such as NMTOKENS may have a child for each token.) |
| * For convenience, the Attribute object's getValue() method returns |
| * the string version of the attribute's value. |
| * <P> |
| * Attributes are not children of the Elements they belong to, in the |
| * usual sense, and have no valid Parent reference. However, the spec |
| * says they _do_ belong to a specific Element, and an INUSE exception |
| * is to be thrown if the user attempts to explicitly share them |
| * between elements. |
| * <P> |
| * Note that Elements do not permit attributes to appear to be shared |
| * (see the INUSE exception), so this object's mutability is |
| * officially not an issue. |
| * <p> |
| * Note: The ownerNode attribute is used to store the Element the Attr |
| * node is associated with. Attr nodes do not have parent nodes. |
| * Besides, the getOwnerElement() method can be used to get the element node |
| * this attribute is associated with. |
| * <P> |
| * AttrImpl does not support Namespaces. AttrNSImpl, which inherits from |
| * it, does. |
| * |
| * <p>AttrImpl used to inherit from ParentNode. It now directly inherits from |
| * NodeImpl and provide its own implementation of the ParentNode's behavior. |
| * The reason is that we now try and avoid to always create a Text node to |
| * hold the value of an attribute. The DOM spec requires it, so we still have |
| * to do it in case getFirstChild() is called for instance. The reason |
| * attribute values are stored as a list of nodes is so that they can carry |
| * more than a simple string. They can also contain EntityReference nodes. |
| * However, most of the times people only have a single string that they only |
| * set and get through Element.set/getAttribute or Attr.set/getValue. In this |
| * new version, the Attr node has a value pointer which can either be the |
| * String directly or a pointer to the first ChildNode. A flag tells which one |
| * it currently is. Note that while we try to stick with the direct String as |
| * much as possible once we've switched to a node there is no going back. This |
| * is because we have no way to know whether the application keeps referring to |
| * the node we once returned. |
| * <p> The gain in memory varies on the density of attributes in the document. |
| * But in the tests I've run I've seen up to 12% of memory gain. And the good |
| * thing is that it also leads to a slight gain in speed because we allocate |
| * fewer objects! I mean, that's until we have to actually create the node... |
| * <p> |
| * To avoid too much duplicated code, I got rid of ParentNode and renamed |
| * ChildAndParentNode, which I never really liked, to ParentNode for |
| * simplicity, this doesn't make much of a difference in memory usage because |
| * there are only very few objects that are only a Parent. This is only true |
| * now because AttrImpl now inherits directly from NodeImpl and has its own |
| * implementation of the ParentNode's node behavior. So there is still some |
| * duplicated code there. |
| * <p> |
| * This class doesn't directly support mutation events, however, it notifies |
| * the document when mutations are performed so that the document class do so. |
| * |
| * <p><b>WARNING</b>: Some of the code here is partially duplicated in |
| * ParentNode, be careful to keep these two classes in sync! |
| * |
| * @xerces.internal |
| * |
| * @see AttrNSImpl |
| * |
| * @author Arnaud Le Hors, IBM |
| * @author Joe Kesselman, IBM |
| * @author Andy Clark, IBM |
| * @version $Id: AttrImpl.java,v 1.5 2008/06/10 00:59:32 joehw Exp $ |
| * @since PR-DOM-Level-1-19980818. |
| * |
| */ |
| public class AttrImpl |
| extends NodeImpl |
| implements Attr, TypeInfo{ |
| |
| // |
| // Constants |
| // |
| |
| /** Serialization version. */ |
| static final long serialVersionUID = 7277707688218972102L; |
| |
| /** DTD namespace. **/ |
| static final String DTD_URI = "http://www.w3.org/TR/REC-xml"; |
| |
| // |
| // Data |
| // |
| |
| /** This can either be a String or the first child node. */ |
| protected Object value = null; |
| |
| /** Attribute name. */ |
| protected String name; |
| |
| /** Type information */ |
| // REVISIT: we are losing the type information in DOM during serialization |
| transient Object type; |
| |
| protected TextImpl textNode = null; |
| |
| // |
| // Constructors |
| // |
| |
| /** |
| * Attribute has no public constructor. Please use the factory |
| * method in the Document class. |
| */ |
| protected AttrImpl(CoreDocumentImpl ownerDocument, String name) { |
| super(ownerDocument); |
| this.name = name; |
| /** False for default attributes. */ |
| isSpecified(true); |
| hasStringValue(true); |
| } |
| |
| // for AttrNSImpl |
| protected AttrImpl() {} |
| |
| // Support for DOM Level 3 renameNode method. |
| // Note: This only deals with part of the pb. It is expected to be |
| // called after the Attr has been detached for one thing. |
| // CoreDocumentImpl does all the work. |
| void rename(String name) { |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| this.name = name; |
| } |
| |
| // create a real text node as child if we don't have one yet |
| protected void makeChildNode() { |
| if (hasStringValue()) { |
| if (value != null) { |
| TextImpl text = |
| (TextImpl) ownerDocument().createTextNode((String) value); |
| value = text; |
| text.isFirstChild(true); |
| text.previousSibling = text; |
| text.ownerNode = this; |
| text.isOwned(true); |
| } |
| hasStringValue(false); |
| } |
| } |
| |
| /** |
| * NON-DOM |
| * set the ownerDocument of this node and its children |
| */ |
| void setOwnerDocument(CoreDocumentImpl doc) { |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| super.setOwnerDocument(doc); |
| if (!hasStringValue()) { |
| for (ChildNode child = (ChildNode) value; |
| child != null; child = child.nextSibling) { |
| child.setOwnerDocument(doc); |
| } |
| } |
| } |
| |
| /** |
| * NON-DOM: set the type of this attribute to be ID type. |
| * |
| * @param id |
| */ |
| public void setIdAttribute(boolean id){ |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| isIdAttribute(id); |
| } |
| /** DOM Level 3: isId*/ |
| public boolean isId(){ |
| // REVISIT: should an attribute that is not in the tree return |
| // isID true? |
| return isIdAttribute(); |
| } |
| |
| |
| // |
| // Node methods |
| // |
| |
| public Node cloneNode(boolean deep) { |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| AttrImpl clone = (AttrImpl) super.cloneNode(deep); |
| |
| // take care of case where there are kids |
| if (!clone.hasStringValue()) { |
| |
| // Need to break the association w/ original kids |
| clone.value = null; |
| |
| // Cloning an Attribute always clones its children, |
| // since they represent its value, no matter whether this |
| // is a deep clone or not |
| for (Node child = (Node) value; child != null; |
| child = child.getNextSibling()) { |
| clone.appendChild(child.cloneNode(true)); |
| } |
| } |
| clone.isSpecified(true); |
| return clone; |
| } |
| |
| /** |
| * 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.ATTRIBUTE_NODE; |
| } |
| |
| /** |
| * Returns the attribute name |
| */ |
| public String getNodeName() { |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| return name; |
| } |
| |
| /** |
| * Implicit in the rerouting of getNodeValue to getValue is the |
| * need to redefine setNodeValue, for symmetry's sake. Note that |
| * since we're explicitly providing a value, Specified should be set |
| * true.... even if that value equals the default. |
| */ |
| public void setNodeValue(String value) throws DOMException { |
| setValue(value); |
| } |
| |
| /** |
| * @see org.w3c.dom.TypeInfo#getTypeName() |
| */ |
| public String getTypeName() { |
| return (String)type; |
| } |
| |
| /** |
| * @see org.w3c.dom.TypeInfo#getTypeNamespace() |
| */ |
| public String getTypeNamespace() { |
| if (type != null) { |
| return DTD_URI; |
| } |
| return null; |
| } |
| |
| /** |
| * Method getSchemaTypeInfo. |
| * @return TypeInfo |
| */ |
| public TypeInfo getSchemaTypeInfo(){ |
| return this; |
| } |
| |
| /** |
| * In Attribute objects, NodeValue is considered a synonym for |
| * Value. |
| * |
| * @see #getValue() |
| */ |
| public String getNodeValue() { |
| return getValue(); |
| } |
| |
| // |
| // Attr methods |
| // |
| |
| /** |
| * In Attributes, NodeName is considered a synonym for the |
| * attribute's Name |
| */ |
| public String getName() { |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| return name; |
| |
| } // getName():String |
| |
| /** |
| * The DOM doesn't clearly define what setValue(null) means. I've taken it |
| * as "remove all children", which from outside should appear |
| * similar to setting it to the empty string. |
| */ |
| public void setValue(String newvalue) { |
| |
| CoreDocumentImpl ownerDocument = ownerDocument(); |
| |
| if (ownerDocument.errorChecking && isReadOnly()) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null); |
| throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg); |
| } |
| |
| Element ownerElement = getOwnerElement(); |
| String oldvalue = ""; |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| if (value != null) { |
| if (ownerDocument.getMutationEvents()) { |
| // Can no longer just discard the kids; they may have |
| // event listeners waiting for them to disconnect. |
| if (hasStringValue()) { |
| oldvalue = (String) value; |
| // create an actual text node as our child so |
| // that we can use it in the event |
| if (textNode == null) { |
| textNode = (TextImpl) |
| ownerDocument.createTextNode((String) value); |
| } |
| else { |
| textNode.data = (String) value; |
| } |
| value = textNode; |
| textNode.isFirstChild(true); |
| textNode.previousSibling = textNode; |
| textNode.ownerNode = this; |
| textNode.isOwned(true); |
| hasStringValue(false); |
| internalRemoveChild(textNode, true); |
| } |
| else { |
| oldvalue = getValue(); |
| while (value != null) { |
| internalRemoveChild((Node) value, true); |
| } |
| } |
| } |
| else { |
| if (hasStringValue()) { |
| oldvalue = (String) value; |
| } |
| else { |
| // simply discard children if any |
| oldvalue = getValue(); |
| // remove ref from first child to last child |
| ChildNode firstChild = (ChildNode) value; |
| firstChild.previousSibling = null; |
| firstChild.isFirstChild(false); |
| firstChild.ownerNode = ownerDocument; |
| } |
| // then remove ref to current value |
| value = null; |
| needsSyncChildren(false); |
| } |
| if (isIdAttribute() && ownerElement != null) { |
| ownerDocument.removeIdentifier(oldvalue); |
| } |
| } |
| |
| // Create and add the new one, generating only non-aggregate events |
| // (There are no listeners on the new Text, but there may be |
| // capture/bubble listeners on the Attr. |
| // Note that aggregate events are NOT dispatched here, |
| // since we need to combine the remove and insert. |
| isSpecified(true); |
| if (ownerDocument.getMutationEvents()) { |
| // if there are any event handlers create a real node |
| internalInsertBefore(ownerDocument.createTextNode(newvalue), |
| null, true); |
| hasStringValue(false); |
| // notify document |
| ownerDocument.modifiedAttrValue(this, oldvalue); |
| } else { |
| // directly store the string |
| value = newvalue; |
| hasStringValue(true); |
| changed(); |
| } |
| if (isIdAttribute() && ownerElement != null) { |
| ownerDocument.putIdentifier(newvalue, ownerElement); |
| } |
| |
| } // setValue(String) |
| |
| /** |
| * The "string value" of an Attribute is its text representation, |
| * which in turn is a concatenation of the string values of its children. |
| */ |
| public String getValue() { |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| if (value == null) { |
| return ""; |
| } |
| if (hasStringValue()) { |
| return (String) value; |
| } |
| |
| ChildNode firstChild = ((ChildNode) value); |
| |
| String data = null; |
| if (firstChild.getNodeType() == Node.ENTITY_REFERENCE_NODE){ |
| data = ((EntityReferenceImpl)firstChild).getEntityRefValue(); |
| } |
| else { |
| data = firstChild.getNodeValue(); |
| } |
| |
| ChildNode node = firstChild.nextSibling; |
| |
| if (node == null || data == null) return (data == null)?"":data; |
| |
| StringBuffer value = new StringBuffer(data); |
| while (node != null) { |
| if (node.getNodeType() == Node.ENTITY_REFERENCE_NODE){ |
| data = ((EntityReferenceImpl)node).getEntityRefValue(); |
| if (data == null) return ""; |
| value.append(data); |
| } |
| else { |
| value.append(node.getNodeValue()); |
| } |
| node = node.nextSibling; |
| } |
| return value.toString(); |
| |
| } // getValue():String |
| |
| |
| /** |
| * The "specified" flag is true if and only if this attribute's |
| * value was explicitly specified in the original document. Note that |
| * the implementation, not the user, is in charge of this |
| * property. If the user asserts an Attribute value (even if it ends |
| * up having the same value as the default), it is considered a |
| * specified attribute. If you really want to revert to the default, |
| * delete the attribute from the Element, and the Implementation will |
| * re-assert the default (if any) in its place, with the appropriate |
| * specified=false setting. |
| */ |
| public boolean getSpecified() { |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| return isSpecified(); |
| |
| } // getSpecified():boolean |
| |
| // |
| // Attr2 methods |
| // |
| |
| /** |
| * Returns the element node that this attribute is associated with, |
| * or null if the attribute has not been added to an element. |
| * |
| * @see #getOwnerElement |
| * |
| * @deprecated Previous working draft of DOM Level 2. New method |
| * is <tt>getOwnerElement()</tt>. |
| */ |
| public Element getElement() { |
| // if we have an owner, ownerNode is our ownerElement, otherwise it's |
| // our ownerDocument and we don't have an ownerElement |
| return (Element) (isOwned() ? ownerNode : null); |
| } |
| |
| /** |
| * Returns the element node that this attribute is associated with, |
| * or null if the attribute has not been added to an element. |
| * |
| * @since WD-DOM-Level-2-19990719 |
| */ |
| public Element getOwnerElement() { |
| // if we have an owner, ownerNode is our ownerElement, otherwise it's |
| // our ownerDocument and we don't have an ownerElement |
| return (Element) (isOwned() ? ownerNode : null); |
| } |
| |
| public void normalize() { |
| |
| // No need to normalize if already normalized or |
| // if value is kept as a String. |
| if (isNormalized() || hasStringValue()) |
| return; |
| |
| Node kid, next; |
| ChildNode firstChild = (ChildNode)value; |
| for (kid = firstChild; kid != null; kid = next) { |
| next = kid.getNextSibling(); |
| |
| // If kid is a text node, we need to check for one of two |
| // conditions: |
| // 1) There is an adjacent text node |
| // 2) There is no adjacent text node, but kid is |
| // an empty text node. |
| if ( kid.getNodeType() == Node.TEXT_NODE ) |
| { |
| // If an adjacent text node, merge it with kid |
| if ( next!=null && next.getNodeType() == Node.TEXT_NODE ) |
| { |
| ((Text)kid).appendData(next.getNodeValue()); |
| removeChild( next ); |
| next = kid; // Don't advance; there might be another. |
| } |
| else |
| { |
| // If kid is empty, remove it |
| if ( kid.getNodeValue() == null || kid.getNodeValue().length() == 0 ) { |
| removeChild( kid ); |
| } |
| } |
| } |
| } |
| |
| isNormalized(true); |
| } // normalize() |
| |
| // |
| // Public methods |
| // |
| |
| /** NON-DOM, for use by parser */ |
| public void setSpecified(boolean arg) { |
| |
| if (needsSyncData()) { |
| synchronizeData(); |
| } |
| isSpecified(arg); |
| |
| } // setSpecified(boolean) |
| |
| /** |
| * NON-DOM: used by the parser |
| * @param type |
| */ |
| public void setType (Object type){ |
| this.type = type; |
| } |
| |
| // |
| // Object methods |
| // |
| |
| /** NON-DOM method for debugging convenience */ |
| public String toString() { |
| return getName() + "=" + "\"" + getValue() + "\""; |
| } |
| |
| /** |
| * Test whether this node has any children. Convenience shorthand |
| * for (Node.getFirstChild()!=null) |
| */ |
| public boolean hasChildNodes() { |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| return value != null; |
| } |
| |
| /** |
| * Obtain a NodeList enumerating all children of this node. If there |
| * are none, an (initially) empty NodeList is returned. |
| * <p> |
| * NodeLists are "live"; as children are added/removed the NodeList |
| * will immediately reflect those changes. Also, the NodeList refers |
| * to the actual nodes, so changes to those nodes made via the DOM tree |
| * will be reflected in the NodeList and vice versa. |
| * <p> |
| * In this implementation, Nodes implement the NodeList interface and |
| * provide their own getChildNodes() support. Other DOMs may solve this |
| * differently. |
| */ |
| public NodeList getChildNodes() { |
| // JKESS: KNOWN ISSUE HERE |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| return this; |
| |
| } // getChildNodes():NodeList |
| |
| /** The first child of this Node, or null if none. */ |
| public Node getFirstChild() { |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| makeChildNode(); |
| return (Node) value; |
| |
| } // getFirstChild():Node |
| |
| /** The last child of this Node, or null if none. */ |
| public Node getLastChild() { |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| return lastChild(); |
| |
| } // getLastChild():Node |
| |
| final ChildNode lastChild() { |
| // last child is stored as the previous sibling of first child |
| makeChildNode(); |
| return value != null ? ((ChildNode) value).previousSibling : null; |
| } |
| |
| final void lastChild(ChildNode node) { |
| // store lastChild as previous sibling of first child |
| if (value != null) { |
| ((ChildNode) value).previousSibling = node; |
| } |
| } |
| |
| /** |
| * Move one or more node(s) to our list of children. Note that this |
| * implicitly removes them from their previous parent. |
| * |
| * @param newChild The Node to be moved to our subtree. As a |
| * convenience feature, inserting a DocumentNode will instead insert |
| * all its children. |
| * |
| * @param refChild Current child which newChild should be placed |
| * immediately before. If refChild is null, the insertion occurs |
| * after all existing Nodes, like appendChild(). |
| * |
| * @return newChild, in its new state (relocated, or emptied in the case of |
| * DocumentNode.) |
| * |
| * @throws DOMException(HIERARCHY_REQUEST_ERR) if newChild is of a |
| * type that shouldn't be a child of this node, or if newChild is an |
| * ancestor of this node. |
| * |
| * @throws DOMException(WRONG_DOCUMENT_ERR) if newChild has a |
| * different owner document than we do. |
| * |
| * @throws DOMException(NOT_FOUND_ERR) if refChild is not a child of |
| * this node. |
| * |
| * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if this node is |
| * read-only. |
| */ |
| public Node insertBefore(Node newChild, Node refChild) |
| throws DOMException { |
| // Tail-call; optimizer should be able to do good things with. |
| return internalInsertBefore(newChild, refChild, false); |
| } // insertBefore(Node,Node):Node |
| |
| /** NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able |
| * to control which mutation events are spawned. This version of the |
| * insertBefore operation allows us to do so. It is not intended |
| * for use by application programs. |
| */ |
| Node internalInsertBefore(Node newChild, Node refChild, boolean replace) |
| throws DOMException { |
| |
| CoreDocumentImpl ownerDocument = ownerDocument(); |
| boolean errorChecking = ownerDocument.errorChecking; |
| |
| if (newChild.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) { |
| // SLOW BUT SAFE: We could insert the whole subtree without |
| // juggling so many next/previous pointers. (Wipe out the |
| // parent's child-list, patch the parent pointers, set the |
| // ends of the list.) But we know some subclasses have special- |
| // case behavior they add to insertBefore(), so we don't risk it. |
| // This approch also takes fewer bytecodes. |
| |
| // NOTE: If one of the children is not a legal child of this |
| // node, throw HIERARCHY_REQUEST_ERR before _any_ of the children |
| // have been transferred. (Alternative behaviors would be to |
| // reparent up to the first failure point or reparent all those |
| // which are acceptable to the target node, neither of which is |
| // as robust. PR-DOM-0818 isn't entirely clear on which it |
| // recommends????? |
| |
| // No need to check kids for right-document; if they weren't, |
| // they wouldn't be kids of that DocFrag. |
| if (errorChecking) { |
| for (Node kid = newChild.getFirstChild(); // Prescan |
| kid != null; kid = kid.getNextSibling()) { |
| |
| if (!ownerDocument.isKidOK(this, kid)) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null); |
| throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, msg); |
| } |
| } |
| } |
| |
| while (newChild.hasChildNodes()) { |
| insertBefore(newChild.getFirstChild(), refChild); |
| } |
| return newChild; |
| } |
| |
| if (newChild == refChild) { |
| // stupid case that must be handled as a no-op triggering events... |
| refChild = refChild.getNextSibling(); |
| removeChild(newChild); |
| insertBefore(newChild, refChild); |
| return newChild; |
| } |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| |
| if (errorChecking) { |
| if (isReadOnly()) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null); |
| throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg); |
| } |
| if (newChild.getOwnerDocument() != ownerDocument) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "WRONG_DOCUMENT_ERR", null); |
| throw new DOMException(DOMException.WRONG_DOCUMENT_ERR, msg); |
| } |
| if (!ownerDocument.isKidOK(this, newChild)) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null); |
| throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, msg); |
| } |
| // refChild must be a child of this node (or null) |
| if (refChild != null && refChild.getParentNode() != this) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null); |
| throw new DOMException(DOMException.NOT_FOUND_ERR, msg); |
| } |
| |
| // Prevent cycles in the tree |
| // newChild cannot be ancestor of this Node, |
| // and actually cannot be this |
| boolean treeSafe = true; |
| for (NodeImpl a = this; treeSafe && a != null; a = a.parentNode()) |
| { |
| treeSafe = newChild != a; |
| } |
| if (!treeSafe) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null); |
| throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, msg); |
| } |
| } |
| |
| makeChildNode(); // make sure we have a node and not a string |
| |
| // notify document |
| ownerDocument.insertingNode(this, replace); |
| |
| // Convert to internal type, to avoid repeated casting |
| ChildNode newInternal = (ChildNode)newChild; |
| |
| Node oldparent = newInternal.parentNode(); |
| if (oldparent != null) { |
| oldparent.removeChild(newInternal); |
| } |
| |
| // Convert to internal type, to avoid repeated casting |
| ChildNode refInternal = (ChildNode) refChild; |
| |
| // Attach up |
| newInternal.ownerNode = this; |
| newInternal.isOwned(true); |
| |
| // Attach before and after |
| // Note: firstChild.previousSibling == lastChild!! |
| ChildNode firstChild = (ChildNode) value; |
| if (firstChild == null) { |
| // this our first and only child |
| value = newInternal; // firstchild = newInternal; |
| newInternal.isFirstChild(true); |
| newInternal.previousSibling = newInternal; |
| } |
| else { |
| if (refInternal == null) { |
| // this is an append |
| ChildNode lastChild = firstChild.previousSibling; |
| lastChild.nextSibling = newInternal; |
| newInternal.previousSibling = lastChild; |
| firstChild.previousSibling = newInternal; |
| } |
| else { |
| // this is an insert |
| if (refChild == firstChild) { |
| // at the head of the list |
| firstChild.isFirstChild(false); |
| newInternal.nextSibling = firstChild; |
| newInternal.previousSibling = firstChild.previousSibling; |
| firstChild.previousSibling = newInternal; |
| value = newInternal; // firstChild = newInternal; |
| newInternal.isFirstChild(true); |
| } |
| else { |
| // somewhere in the middle |
| ChildNode prev = refInternal.previousSibling; |
| newInternal.nextSibling = refInternal; |
| prev.nextSibling = newInternal; |
| refInternal.previousSibling = newInternal; |
| newInternal.previousSibling = prev; |
| } |
| } |
| } |
| |
| changed(); |
| |
| // notify document |
| ownerDocument.insertedNode(this, newInternal, replace); |
| |
| checkNormalizationAfterInsert(newInternal); |
| |
| return newChild; |
| |
| } // internalInsertBefore(Node,Node,int):Node |
| |
| /** |
| * Remove a child from this Node. The removed child's subtree |
| * remains intact so it may be re-inserted elsewhere. |
| * |
| * @return oldChild, in its new state (removed). |
| * |
| * @throws DOMException(NOT_FOUND_ERR) if oldChild is not a child of |
| * this node. |
| * |
| * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if this node is |
| * read-only. |
| */ |
| public Node removeChild(Node oldChild) |
| throws DOMException { |
| // Tail-call, should be optimizable |
| if (hasStringValue()) { |
| // we don't have any child per say so it can't be one of them! |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null); |
| throw new DOMException(DOMException.NOT_FOUND_ERR, msg); |
| } |
| return internalRemoveChild(oldChild, false); |
| } // removeChild(Node) :Node |
| |
| /** NON-DOM INTERNAL: Within DOM actions,we sometimes need to be able |
| * to control which mutation events are spawned. This version of the |
| * removeChild operation allows us to do so. It is not intended |
| * for use by application programs. |
| */ |
| Node internalRemoveChild(Node oldChild, boolean replace) |
| throws DOMException { |
| |
| CoreDocumentImpl ownerDocument = ownerDocument(); |
| if (ownerDocument.errorChecking) { |
| if (isReadOnly()) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null); |
| throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg); |
| } |
| if (oldChild != null && oldChild.getParentNode() != this) { |
| String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null); |
| throw new DOMException(DOMException.NOT_FOUND_ERR, msg); |
| } |
| } |
| |
| ChildNode oldInternal = (ChildNode) oldChild; |
| |
| // notify document |
| ownerDocument.removingNode(this, oldInternal, replace); |
| |
| // Patch linked list around oldChild |
| // Note: lastChild == firstChild.previousSibling |
| if (oldInternal == value) { // oldInternal == firstChild |
| // removing first child |
| oldInternal.isFirstChild(false); |
| // next line is: firstChild = oldInternal.nextSibling |
| value = oldInternal.nextSibling; |
| ChildNode firstChild = (ChildNode) value; |
| if (firstChild != null) { |
| firstChild.isFirstChild(true); |
| firstChild.previousSibling = oldInternal.previousSibling; |
| } |
| } else { |
| ChildNode prev = oldInternal.previousSibling; |
| ChildNode next = oldInternal.nextSibling; |
| prev.nextSibling = next; |
| if (next == null) { |
| // removing last child |
| ChildNode firstChild = (ChildNode) value; |
| firstChild.previousSibling = prev; |
| } else { |
| // removing some other child in the middle |
| next.previousSibling = prev; |
| } |
| } |
| |
| // Save previous sibling for normalization checking. |
| ChildNode oldPreviousSibling = oldInternal.previousSibling(); |
| |
| // Remove oldInternal's references to tree |
| oldInternal.ownerNode = ownerDocument; |
| oldInternal.isOwned(false); |
| oldInternal.nextSibling = null; |
| oldInternal.previousSibling = null; |
| |
| changed(); |
| |
| // notify document |
| ownerDocument.removedNode(this, replace); |
| |
| checkNormalizationAfterRemove(oldPreviousSibling); |
| |
| return oldInternal; |
| |
| } // internalRemoveChild(Node,int):Node |
| |
| /** |
| * Make newChild occupy the location that oldChild used to |
| * have. Note that newChild will first be removed from its previous |
| * parent, if any. Equivalent to inserting newChild before oldChild, |
| * then removing oldChild. |
| * |
| * @return oldChild, in its new state (removed). |
| * |
| * @throws DOMException(HIERARCHY_REQUEST_ERR) if newChild is of a |
| * type that shouldn't be a child of this node, or if newChild is |
| * one of our ancestors. |
| * |
| * @throws DOMException(WRONG_DOCUMENT_ERR) if newChild has a |
| * different owner document than we do. |
| * |
| * @throws DOMException(NOT_FOUND_ERR) if oldChild is not a child of |
| * this node. |
| * |
| * @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if this node is |
| * read-only. |
| */ |
| public Node replaceChild(Node newChild, Node oldChild) |
| throws DOMException { |
| |
| makeChildNode(); |
| |
| // If Mutation Events are being generated, this operation might |
| // throw aggregate events twice when modifying an Attr -- once |
| // on insertion and once on removal. DOM Level 2 does not specify |
| // this as either desirable or undesirable, but hints that |
| // aggregations should be issued only once per user request. |
| |
| // notify document |
| CoreDocumentImpl ownerDocument = ownerDocument(); |
| ownerDocument.replacingNode(this); |
| |
| internalInsertBefore(newChild, oldChild, true); |
| if (newChild != oldChild) { |
| internalRemoveChild(oldChild, true); |
| } |
| |
| // notify document |
| ownerDocument.replacedNode(this); |
| |
| return oldChild; |
| } |
| |
| // |
| // NodeList methods |
| // |
| |
| /** |
| * NodeList method: Count the immediate children of this node |
| * @return int |
| */ |
| public int getLength() { |
| |
| if (hasStringValue()) { |
| return 1; |
| } |
| ChildNode node = (ChildNode) value; |
| int length = 0; |
| for (; node != null; node = node.nextSibling) { |
| length++; |
| } |
| return length; |
| |
| } // getLength():int |
| |
| /** |
| * NodeList method: Return the Nth immediate child of this node, or |
| * null if the index is out of bounds. |
| * @return org.w3c.dom.Node |
| * @param Index int |
| */ |
| public Node item(int index) { |
| |
| if (hasStringValue()) { |
| if (index != 0 || value == null) { |
| return null; |
| } |
| else { |
| makeChildNode(); |
| return (Node) value; |
| } |
| } |
| if (index < 0) { |
| return null; |
| } |
| ChildNode node = (ChildNode) value; |
| for (int i = 0; i < index && node != null; i++) { |
| node = node.nextSibling; |
| } |
| return node; |
| |
| } // item(int):Node |
| |
| // |
| // DOM3 |
| // |
| |
| /** |
| * DOM Level 3 WD- Experimental. |
| * Override inherited behavior from ParentNode to support deep equal. |
| * isEqualNode is always deep on Attr nodes. |
| */ |
| public boolean isEqualNode(Node arg) { |
| return super.isEqualNode(arg); |
| } |
| |
| /** |
| * Introduced in DOM Level 3. <p> |
| * Checks if a type is derived from another by restriction. See: |
| * http://www.w3.org/TR/DOM-Level-3-Core/core.html#TypeInfo-isDerivedFrom |
| * |
| * @param ancestorNS |
| * The namspace of the ancestor type declaration |
| * @param ancestorName |
| * The name of the ancestor type declaration |
| * @param type |
| * The reference type definition |
| * |
| * @return boolean True if the type is derived by restriciton for the |
| * reference type |
| */ |
| public boolean isDerivedFrom(String typeNamespaceArg, |
| String typeNameArg, |
| int derivationMethod) { |
| |
| return false; |
| } |
| |
| |
| // |
| // Public methods |
| // |
| |
| /** |
| * Override default behavior so that if deep is true, children are also |
| * toggled. |
| * @see Node |
| * <P> |
| * Note: this will not change the state of an EntityReference or its |
| * children, which are always read-only. |
| */ |
| public void setReadOnly(boolean readOnly, boolean deep) { |
| |
| super.setReadOnly(readOnly, deep); |
| |
| if (deep) { |
| |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| |
| if (hasStringValue()) { |
| return; |
| } |
| // Recursively set kids |
| for (ChildNode mykid = (ChildNode) value; |
| mykid != null; |
| mykid = mykid.nextSibling) { |
| if (mykid.getNodeType() != Node.ENTITY_REFERENCE_NODE) { |
| mykid.setReadOnly(readOnly,true); |
| } |
| } |
| } |
| } // setReadOnly(boolean,boolean) |
| |
| // |
| // Protected methods |
| // |
| |
| /** |
| * Override this method in subclass to hook in efficient |
| * internal data structure. |
| */ |
| protected void synchronizeChildren() { |
| // By default just change the flag to avoid calling this method again |
| needsSyncChildren(false); |
| } |
| |
| /** |
| * Checks the normalized state of this node after inserting a child. |
| * If the inserted child causes this node to be unnormalized, then this |
| * node is flagged accordingly. |
| * The conditions for changing the normalized state are: |
| * <ul> |
| * <li>The inserted child is a text node and one of its adjacent siblings |
| * is also a text node. |
| * <li>The inserted child is is itself unnormalized. |
| * </ul> |
| * |
| * @param insertedChild the child node that was inserted into this node |
| * |
| * @throws NullPointerException if the inserted child is <code>null</code> |
| */ |
| void checkNormalizationAfterInsert(ChildNode insertedChild) { |
| // See if insertion caused this node to be unnormalized. |
| if (insertedChild.getNodeType() == Node.TEXT_NODE) { |
| ChildNode prev = insertedChild.previousSibling(); |
| ChildNode next = insertedChild.nextSibling; |
| // If an adjacent sibling of the new child is a text node, |
| // flag this node as unnormalized. |
| if ((prev != null && prev.getNodeType() == Node.TEXT_NODE) || |
| (next != null && next.getNodeType() == Node.TEXT_NODE)) { |
| isNormalized(false); |
| } |
| } |
| else { |
| // If the new child is not normalized, |
| // then this node is inherently not normalized. |
| if (!insertedChild.isNormalized()) { |
| isNormalized(false); |
| } |
| } |
| } // checkNormalizationAfterInsert(ChildNode) |
| |
| /** |
| * Checks the normalized of this node after removing a child. |
| * If the removed child causes this node to be unnormalized, then this |
| * node is flagged accordingly. |
| * The conditions for changing the normalized state are: |
| * <ul> |
| * <li>The removed child had two adjacent siblings that were text nodes. |
| * </ul> |
| * |
| * @param previousSibling the previous sibling of the removed child, or |
| * <code>null</code> |
| */ |
| void checkNormalizationAfterRemove(ChildNode previousSibling) { |
| // See if removal caused this node to be unnormalized. |
| // If the adjacent siblings of the removed child were both text nodes, |
| // flag this node as unnormalized. |
| if (previousSibling != null && |
| previousSibling.getNodeType() == Node.TEXT_NODE) { |
| |
| ChildNode next = previousSibling.nextSibling; |
| if (next != null && next.getNodeType() == Node.TEXT_NODE) { |
| isNormalized(false); |
| } |
| } |
| } // checkNormalizationAfterRemove(ChildNode) |
| |
| // |
| // Serialization methods |
| // |
| |
| /** Serialize object. */ |
| private void writeObject(ObjectOutputStream out) throws IOException { |
| |
| // synchronize chilren |
| if (needsSyncChildren()) { |
| synchronizeChildren(); |
| } |
| // write object |
| out.defaultWriteObject(); |
| |
| } // writeObject(ObjectOutputStream) |
| |
| /** Deserialize object. */ |
| private void readObject(ObjectInputStream ois) |
| throws ClassNotFoundException, IOException { |
| |
| // perform default deseralization |
| ois.defaultReadObject(); |
| |
| // hardset synchildren - so we don't try to sync - |
| // it does not make any sense to try to synchildren when we just |
| // deserialize object. |
| needsSyncChildren(false); |
| |
| } // readObject(ObjectInputStream) |
| |
| |
| } // class AttrImpl |
