You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1038 lines
36 KiB
1038 lines
36 KiB
/*
|
|
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
*/
|
|
/*
|
|
* 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 java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.Serializable;
|
|
|
|
import org.w3c.dom.DOMException;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Node;
|
|
import org.w3c.dom.NodeList;
|
|
import org.w3c.dom.UserDataHandler;
|
|
|
|
/**
|
|
* ParentNode inherits from ChildNode and adds the capability of having child
|
|
* nodes. Not every node in the DOM can have children, so only nodes that can
|
|
* should inherit from this class and pay the price for it.
|
|
* <P>
|
|
* ParentNode, just like NodeImpl, also implements NodeList, so it can
|
|
* return itself in response to the getChildNodes() query. This eliminiates
|
|
* the need for a separate ChildNodeList object. Note that this is an
|
|
* IMPLEMENTATION DETAIL; applications should _never_ assume that
|
|
* this identity exists. On the other hand, subclasses may need to override
|
|
* this, in case of conflicting names. This is the case for the classes
|
|
* HTMLSelectElementImpl and HTMLFormElementImpl of the HTML DOM.
|
|
* <P>
|
|
* While we have a direct reference to the first child, the last child is
|
|
* stored as the previous sibling of the first child. First child nodes are
|
|
* marked as being so, and getNextSibling hides this fact.
|
|
* <P>Note: Not all parent nodes actually need to also be a child. At some
|
|
* point we used to have ParentNode inheriting from NodeImpl and another class
|
|
* called ChildAndParentNode that inherited from ChildNode. But due to the lack
|
|
* of multiple inheritance a lot of code had to be duplicated which led to a
|
|
* maintenance nightmare. At the same time only a few nodes (Document,
|
|
* DocumentFragment, Entity, and Attribute) cannot be a child so the gain in
|
|
* memory wasn't really worth it. The only type for which this would be the
|
|
* case is Attribute, but we deal with there in another special way, so this is
|
|
* not applicable.
|
|
* <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
|
|
* AttrImpl, be careful to keep these two classes in sync!
|
|
*
|
|
* @xerces.internal
|
|
*
|
|
* @author Arnaud Le Hors, IBM
|
|
* @author Joe Kesselman, IBM
|
|
* @author Andy Clark, IBM
|
|
* @version $Id: ParentNode.java,v 1.6 2009/07/21 20:30:28 joehw Exp $
|
|
*/
|
|
public abstract class ParentNode
|
|
extends ChildNode {
|
|
|
|
/** Serialization version. */
|
|
static final long serialVersionUID = 2815829867152120872L;
|
|
|
|
/** Owner document. */
|
|
protected CoreDocumentImpl ownerDocument;
|
|
|
|
/** First child. */
|
|
protected ChildNode firstChild = null;
|
|
|
|
// transients
|
|
|
|
/** NodeList cache */
|
|
protected transient NodeListCache fNodeListCache = null;
|
|
|
|
//
|
|
// Constructors
|
|
//
|
|
|
|
/**
|
|
* No public constructor; only subclasses of ParentNode should be
|
|
* instantiated, and those normally via a Document's factory methods
|
|
*/
|
|
protected ParentNode(CoreDocumentImpl ownerDocument) {
|
|
super(ownerDocument);
|
|
this.ownerDocument = ownerDocument;
|
|
}
|
|
|
|
/** Constructor for serialization. */
|
|
public ParentNode() {}
|
|
|
|
//
|
|
// NodeList methods
|
|
//
|
|
|
|
/**
|
|
* Returns a duplicate of a given node. You can consider this a
|
|
* generic "copy constructor" for nodes. The newly returned object should
|
|
* be completely independent of the source object's subtree, so changes
|
|
* in one after the clone has been made will not affect the other.
|
|
* <p>
|
|
* Example: Cloning a Text node will copy both the node and the text it
|
|
* contains.
|
|
* <p>
|
|
* Example: Cloning something that has children -- Element or Attr, for
|
|
* example -- will _not_ clone those children unless a "deep clone"
|
|
* has been requested. A shallow clone of an Attr node will yield an
|
|
* empty Attr of the same name.
|
|
* <p>
|
|
* NOTE: Clones will always be read/write, even if the node being cloned
|
|
* is read-only, to permit applications using only the DOM API to obtain
|
|
* editable copies of locked portions of the tree.
|
|
*/
|
|
public Node cloneNode(boolean deep) {
|
|
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
ParentNode newnode = (ParentNode) super.cloneNode(deep);
|
|
|
|
// set owner document
|
|
newnode.ownerDocument = ownerDocument;
|
|
|
|
// Need to break the association w/ original kids
|
|
newnode.firstChild = null;
|
|
|
|
// invalidate cache for children NodeList
|
|
newnode.fNodeListCache = null;
|
|
|
|
// Then, if deep, clone the kids too.
|
|
if (deep) {
|
|
for (ChildNode child = firstChild;
|
|
child != null;
|
|
child = child.nextSibling) {
|
|
newnode.appendChild(child.cloneNode(true));
|
|
}
|
|
}
|
|
|
|
return newnode;
|
|
|
|
} // cloneNode(boolean):Node
|
|
|
|
/**
|
|
* Find the Document that this Node belongs to (the document in
|
|
* whose context the Node was created). The Node may or may not
|
|
* currently be part of that Document's actual contents.
|
|
*/
|
|
public Document getOwnerDocument() {
|
|
return ownerDocument;
|
|
}
|
|
|
|
/**
|
|
* same as above but returns internal type and this one is not overridden
|
|
* by CoreDocumentImpl to return null
|
|
*/
|
|
CoreDocumentImpl ownerDocument() {
|
|
return ownerDocument;
|
|
}
|
|
|
|
/**
|
|
* NON-DOM
|
|
* set the ownerDocument of this node and its children
|
|
*/
|
|
void setOwnerDocument(CoreDocumentImpl doc) {
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
for (ChildNode child = firstChild;
|
|
child != null; child = child.nextSibling) {
|
|
child.setOwnerDocument(doc);
|
|
}
|
|
/* setting the owner document of self, after it's children makes the
|
|
data of children available to the new document. */
|
|
super.setOwnerDocument(doc);
|
|
ownerDocument = doc;
|
|
}
|
|
|
|
/**
|
|
* Test whether this node has any children. Convenience shorthand
|
|
* for (Node.getFirstChild()!=null)
|
|
*/
|
|
public boolean hasChildNodes() {
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
return firstChild != 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() {
|
|
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
return this;
|
|
|
|
} // getChildNodes():NodeList
|
|
|
|
/** The first child of this Node, or null if none. */
|
|
public Node getFirstChild() {
|
|
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
return firstChild;
|
|
|
|
} // 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
|
|
return firstChild != null ? firstChild.previousSibling : null;
|
|
}
|
|
|
|
final void lastChild(ChildNode node) {
|
|
// store lastChild as previous sibling of first child
|
|
if (firstChild != null) {
|
|
firstChild.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 {
|
|
|
|
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)) {
|
|
throw new DOMException(
|
|
DOMException.HIERARCHY_REQUEST_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
|
|
}
|
|
}
|
|
}
|
|
|
|
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()) {
|
|
throw new DOMException(
|
|
DOMException.NO_MODIFICATION_ALLOWED_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
|
|
}
|
|
if (newChild.getOwnerDocument() != ownerDocument && newChild != ownerDocument) {
|
|
throw new DOMException(DOMException.WRONG_DOCUMENT_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "WRONG_DOCUMENT_ERR", null));
|
|
}
|
|
if (!ownerDocument.isKidOK(this, newChild)) {
|
|
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
|
|
}
|
|
// refChild must be a child of this node (or null)
|
|
if (refChild != null && refChild.getParentNode() != this) {
|
|
throw new DOMException(DOMException.NOT_FOUND_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null));
|
|
}
|
|
|
|
// Prevent cycles in the tree
|
|
// newChild cannot be ancestor of this Node,
|
|
// and actually cannot be this
|
|
if (ownerDocument.ancestorChecking) {
|
|
boolean treeSafe = true;
|
|
for (NodeImpl a = this; treeSafe && a != null; a = a.parentNode())
|
|
{
|
|
treeSafe = newChild != a;
|
|
}
|
|
if(!treeSafe) {
|
|
throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "HIERARCHY_REQUEST_ERR", null));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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!!
|
|
if (firstChild == null) {
|
|
// this our first and only child
|
|
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;
|
|
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();
|
|
|
|
// update cached length if we have any
|
|
if (fNodeListCache != null) {
|
|
if (fNodeListCache.fLength != -1) {
|
|
fNodeListCache.fLength++;
|
|
}
|
|
if (fNodeListCache.fChildIndex != -1) {
|
|
// if we happen to insert just before the cached node, update
|
|
// the cache to the new node to match the cached index
|
|
if (fNodeListCache.fChild == refInternal) {
|
|
fNodeListCache.fChild = newInternal;
|
|
} else {
|
|
// otherwise just invalidate the cache
|
|
fNodeListCache.fChildIndex = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// notify document
|
|
ownerDocument.insertedNode(this, newInternal, replace);
|
|
|
|
checkNormalizationAfterInsert(newInternal);
|
|
|
|
return newChild;
|
|
|
|
} // internalInsertBefore(Node,Node,boolean):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
|
|
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()) {
|
|
throw new DOMException(
|
|
DOMException.NO_MODIFICATION_ALLOWED_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
|
|
}
|
|
if (oldChild != null && oldChild.getParentNode() != this) {
|
|
throw new DOMException(DOMException.NOT_FOUND_ERR,
|
|
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR", null));
|
|
}
|
|
}
|
|
|
|
ChildNode oldInternal = (ChildNode) oldChild;
|
|
|
|
// notify document
|
|
ownerDocument.removingNode(this, oldInternal, replace);
|
|
|
|
// update cached length if we have any
|
|
if (fNodeListCache != null) {
|
|
if (fNodeListCache.fLength != -1) {
|
|
fNodeListCache.fLength--;
|
|
}
|
|
if (fNodeListCache.fChildIndex != -1) {
|
|
// if the removed node is the cached node
|
|
// move the cache to its (soon former) previous sibling
|
|
if (fNodeListCache.fChild == oldInternal) {
|
|
fNodeListCache.fChildIndex--;
|
|
fNodeListCache.fChild = oldInternal.previousSibling();
|
|
} else {
|
|
// otherwise just invalidate the cache
|
|
fNodeListCache.fChildIndex = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Patch linked list around oldChild
|
|
// Note: lastChild == firstChild.previousSibling
|
|
if (oldInternal == firstChild) {
|
|
// removing first child
|
|
oldInternal.isFirstChild(false);
|
|
firstChild = oldInternal.nextSibling;
|
|
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
|
|
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,boolean):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 {
|
|
// 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
|
|
ownerDocument.replacingNode(this);
|
|
|
|
internalInsertBefore(newChild, oldChild, true);
|
|
if (newChild != oldChild) {
|
|
internalRemoveChild(oldChild, true);
|
|
}
|
|
|
|
// notify document
|
|
ownerDocument.replacedNode(this);
|
|
|
|
return oldChild;
|
|
}
|
|
|
|
/*
|
|
* Get Node text content
|
|
* @since DOM Level 3
|
|
*/
|
|
public String getTextContent() throws DOMException {
|
|
Node child = getFirstChild();
|
|
if (child != null) {
|
|
Node next = child.getNextSibling();
|
|
if (next == null) {
|
|
return hasTextContent(child) ? ((NodeImpl) child).getTextContent() : "";
|
|
}
|
|
if (fBufferStr == null){
|
|
fBufferStr = new StringBuffer();
|
|
}
|
|
else {
|
|
fBufferStr.setLength(0);
|
|
}
|
|
getTextContent(fBufferStr);
|
|
return fBufferStr.toString();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
// internal method taking a StringBuffer in parameter
|
|
void getTextContent(StringBuffer buf) throws DOMException {
|
|
Node child = getFirstChild();
|
|
while (child != null) {
|
|
if (hasTextContent(child)) {
|
|
((NodeImpl) child).getTextContent(buf);
|
|
}
|
|
child = child.getNextSibling();
|
|
}
|
|
}
|
|
|
|
// internal method returning whether to take the given node's text content
|
|
final boolean hasTextContent(Node child) {
|
|
return child.getNodeType() != Node.COMMENT_NODE &&
|
|
child.getNodeType() != Node.PROCESSING_INSTRUCTION_NODE &&
|
|
(child.getNodeType() != Node.TEXT_NODE ||
|
|
((TextImpl) child).isIgnorableWhitespace() == false);
|
|
}
|
|
|
|
/*
|
|
* Set Node text content
|
|
* @since DOM Level 3
|
|
*/
|
|
public void setTextContent(String textContent)
|
|
throws DOMException {
|
|
// get rid of any existing children
|
|
Node child;
|
|
while ((child = getFirstChild()) != null) {
|
|
removeChild(child);
|
|
}
|
|
// create a Text node to hold the given content
|
|
if (textContent != null && textContent.length() != 0){
|
|
appendChild(ownerDocument().createTextNode(textContent));
|
|
}
|
|
}
|
|
|
|
//
|
|
// NodeList methods
|
|
//
|
|
|
|
/**
|
|
* Count the immediate children of this node. Use to implement
|
|
* NodeList.getLength().
|
|
* @return int
|
|
*/
|
|
private int nodeListGetLength() {
|
|
|
|
if (fNodeListCache == null) {
|
|
// get rid of trivial cases
|
|
if (firstChild == null) {
|
|
return 0;
|
|
}
|
|
if (firstChild == lastChild()) {
|
|
return 1;
|
|
}
|
|
// otherwise request a cache object
|
|
fNodeListCache = ownerDocument.getNodeListCache(this);
|
|
}
|
|
if (fNodeListCache.fLength == -1) { // is the cached length invalid ?
|
|
int l;
|
|
ChildNode n;
|
|
// start from the cached node if we have one
|
|
if (fNodeListCache.fChildIndex != -1 &&
|
|
fNodeListCache.fChild != null) {
|
|
l = fNodeListCache.fChildIndex;
|
|
n = fNodeListCache.fChild;
|
|
} else {
|
|
n = firstChild;
|
|
l = 0;
|
|
}
|
|
while (n != null) {
|
|
l++;
|
|
n = n.nextSibling;
|
|
}
|
|
fNodeListCache.fLength = l;
|
|
}
|
|
|
|
return fNodeListCache.fLength;
|
|
|
|
} // nodeListGetLength():int
|
|
|
|
/**
|
|
* NodeList method: Count the immediate children of this node
|
|
* @return int
|
|
*/
|
|
public int getLength() {
|
|
return nodeListGetLength();
|
|
}
|
|
|
|
/**
|
|
* Return the Nth immediate child of this node, or null if the index is
|
|
* out of bounds. Use to implement NodeList.item().
|
|
* @param index int
|
|
*/
|
|
private Node nodeListItem(int index) {
|
|
|
|
if (fNodeListCache == null) {
|
|
// get rid of trivial case
|
|
if (firstChild == lastChild()) {
|
|
return index == 0 ? firstChild : null;
|
|
}
|
|
// otherwise request a cache object
|
|
fNodeListCache = ownerDocument.getNodeListCache(this);
|
|
}
|
|
int i = fNodeListCache.fChildIndex;
|
|
ChildNode n = fNodeListCache.fChild;
|
|
boolean firstAccess = true;
|
|
// short way
|
|
if (i != -1 && n != null) {
|
|
firstAccess = false;
|
|
if (i < index) {
|
|
while (i < index && n != null) {
|
|
i++;
|
|
n = n.nextSibling;
|
|
}
|
|
}
|
|
else if (i > index) {
|
|
while (i > index && n != null) {
|
|
i--;
|
|
n = n.previousSibling();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// long way
|
|
if (index < 0) {
|
|
return null;
|
|
}
|
|
n = firstChild;
|
|
for (i = 0; i < index && n != null; i++) {
|
|
n = n.nextSibling;
|
|
}
|
|
}
|
|
|
|
// release cache if reaching last child or first child
|
|
if (!firstAccess && (n == firstChild || n == lastChild())) {
|
|
fNodeListCache.fChildIndex = -1;
|
|
fNodeListCache.fChild = null;
|
|
ownerDocument.freeNodeListCache(fNodeListCache);
|
|
// we can keep using the cache until it is actually reused
|
|
// fNodeListCache will be nulled by the pool (document) if that
|
|
// happens.
|
|
// fNodeListCache = null;
|
|
}
|
|
else {
|
|
// otherwise update it
|
|
fNodeListCache.fChildIndex = i;
|
|
fNodeListCache.fChild = n;
|
|
}
|
|
return n;
|
|
|
|
} // nodeListItem(int):Node
|
|
|
|
/**
|
|
* 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) {
|
|
return nodeListItem(index);
|
|
} // item(int):Node
|
|
|
|
/**
|
|
* Create a NodeList to access children that is use by subclass elements
|
|
* that have methods named getLength() or item(int). ChildAndParentNode
|
|
* optimizes getChildNodes() by implementing NodeList itself. However if
|
|
* a subclass Element implements methods with the same name as the NodeList
|
|
* methods, they will override the actually methods in this class.
|
|
* <p>
|
|
* To use this method, the subclass should implement getChildNodes() and
|
|
* have it call this method. The resulting NodeList instance maybe
|
|
* shared and cached in a transient field, but the cached value must be
|
|
* cleared if the node is cloned.
|
|
*/
|
|
protected final NodeList getChildNodesUnoptimized() {
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
return new NodeList() {
|
|
/**
|
|
* @see NodeList.getLength()
|
|
*/
|
|
public int getLength() {
|
|
return nodeListGetLength();
|
|
} // getLength():int
|
|
|
|
/**
|
|
* @see NodeList.item(int)
|
|
*/
|
|
public Node item(int index) {
|
|
return nodeListItem(index);
|
|
} // item(int):Node
|
|
};
|
|
} // getChildNodesUnoptimized():NodeList
|
|
|
|
//
|
|
// DOM2: methods, getters, setters
|
|
//
|
|
|
|
/**
|
|
* Override default behavior to call normalize() on this Node's
|
|
* children. It is up to implementors or Node to override normalize()
|
|
* to take action.
|
|
*/
|
|
public void normalize() {
|
|
// No need to normalize if already normalized.
|
|
if (isNormalized()) {
|
|
return;
|
|
}
|
|
if (needsSyncChildren()) {
|
|
synchronizeChildren();
|
|
}
|
|
ChildNode kid;
|
|
for (kid = firstChild; kid != null; kid = kid.nextSibling) {
|
|
kid.normalize();
|
|
}
|
|
isNormalized(true);
|
|
}
|
|
|
|
/**
|
|
* DOM Level 3 WD- Experimental.
|
|
* Override inherited behavior from NodeImpl to support deep equal.
|
|
*/
|
|
public boolean isEqualNode(Node arg) {
|
|
if (!super.isEqualNode(arg)) {
|
|
return false;
|
|
}
|
|
// there are many ways to do this test, and there isn't any way
|
|
// better than another. Performance may vary greatly depending on
|
|
// the implementations involved. This one should work fine for us.
|
|
Node child1 = getFirstChild();
|
|
Node child2 = arg.getFirstChild();
|
|
while (child1 != null && child2 != null) {
|
|
if (!((NodeImpl) child1).isEqualNode(child2)) {
|
|
return false;
|
|
}
|
|
child1 = child1.getNextSibling();
|
|
child2 = child2.getNextSibling();
|
|
}
|
|
if (child1 != child2) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// 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();
|
|
}
|
|
|
|
// Recursively set kids
|
|
for (ChildNode mykid = firstChild;
|
|
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(Node)
|
|
|
|
//
|
|
// 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)
|
|
|
|
/*
|
|
* a class to store some user data along with its handler
|
|
*/
|
|
protected class UserDataRecord implements Serializable {
|
|
/** Serialization version. */
|
|
private static final long serialVersionUID = 3258126977134310455L;
|
|
|
|
Object fData;
|
|
UserDataHandler fHandler;
|
|
UserDataRecord(Object data, UserDataHandler handler) {
|
|
fData = data;
|
|
fHandler = handler;
|
|
}
|
|
}
|
|
} // class ParentNode
|