/*
* 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 org.apache.xerces.dom;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import javax.xml.stream.events.Namespace;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
import at.ac.tuwien.dsg.scaledom.dom.ChildNodeList;
import at.ac.tuwien.dsg.scaledom.dom.ScaleDomDocument;
import at.ac.tuwien.dsg.scaledom.dom.WeakChildNodeList;
import at.ac.tuwien.dsg.scaledom.io.NodeLocation;
/**
* 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 724081 2008-12-07 05:46:26Z mrglavas $
*/
public abstract class ParentNode extends ChildNode {
// <ScaleDOM>
private final static Logger log = LoggerFactory.getLogger(ParentNode.class);
// </ScaleDOM>
/** 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;
// <ScaleDOM>
/**
* Weak reference to list of child nodes.<br/>
* May be cleared by garbage collector if no hard reference points to at least one of the children.
*/
private WeakChildNodeList children;
/** Parent needs to know if it has any children, keep exact number for performance reasons. */
private int numberOfChildren;
/** Location information, required for reloading the parent and its children. */
private NodeLocation location;
/** Namespace declarations on this node (as declared in underlying document source). */
private List<Namespace> namespaces;
protected boolean isScaleDomEnabled() {
return ownerDocument instanceof ScaleDomDocument;
}
// </ScaleDOM>
//
// 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;
// <ScaleDOM>
if(isScaleDomEnabled()) {
final ScaleDomDocument doc = (ScaleDomDocument) ownerDocument;
this.children = new WeakChildNodeList(doc, this, null);
this.numberOfChildren = 0;
this.location = null;
this.namespaces = new ArrayList<Namespace>();
}
// </ScaleDOM>
}
/** 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;
// <ScaleDOM>
if(isScaleDomEnabled()) {
newnode.children.clear();
newnode.numberOfChildren = deep ? numberOfChildren : 0;
newnode.location = location;
newnode.namespaces = namespaces;
} else {
// Need to break the association w/ original kids
newnode.firstChild = null;
// invalidate cache for children NodeList
newnode.fNodeListCache = null;
}
// </ScaleDOM>
// Then, if deep, clone the kids too.
if (deep) {
// <ScaleDOM>
ChildNode firstChild = null;
if(isScaleDomEnabled()) {
firstChild = getFirstLoadedChildNode();
} else {
firstChild = this.firstChild;
}
// </ScaleDOM>
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
*/
protected void setOwnerDocument(CoreDocumentImpl doc) {
if (needsSyncChildren()) {
synchronizeChildren();
}
super.setOwnerDocument(doc);
ownerDocument = doc;
// <ScaleDOM>
ChildNode firstChild = null;
if(isScaleDomEnabled()) {
firstChild = getFirstLoadedChildNode();
} else {
firstChild = this.firstChild;
}
// </ScaleDOM>
for (ChildNode child = firstChild; child != null; child = child.nextSibling) {
child.setOwnerDocument(doc);
}
}
/**
* Test whether this node has any children. Convenience shorthand for (Node.getFirstChild()!=null)
*/
public boolean hasChildNodes() {
if (needsSyncChildren()) {
synchronizeChildren();
}
// <ScaleDOM>
if(isScaleDomEnabled()) {
return numberOfChildren > 0;
} else {
return firstChild != null;
}
// </ScaleDOM>
}
/**
* 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();
}
// <ScaleDOM>
if(isScaleDomEnabled()) {
return new ChildNodeList(getAllChildNodes());
} else {
return this;
}
// </ScaleDOM>
} // getChildNodes():NodeList
/** The first child of this Node, or null if none. */
public Node getFirstChild() {
if (needsSyncChildren()) {
synchronizeChildren();
}
// <ScaleDOM>
if(isScaleDomEnabled()) {
if (!hasChildNodes()) {
return null;
}
final LinkedList<ChildNode> allChildren = getAllChildNodes();
if (allChildren.isEmpty()) {
// Some error occurred (most probably while reloading the children)
return null;
}
return allChildren.getFirst();
} else {
return firstChild;
}
// </ScaleDOM>
} // getFirstChild():Node
/** The last child of this Node, or null if none. */
public Node getLastChild() {
if (needsSyncChildren()) {
synchronizeChildren();
}
// <ScaleDOM>
if(isScaleDomEnabled()) {
if (!hasChildNodes()) {
return null;
}
final LinkedList<ChildNode> allChildren = getAllChildNodes();
if (allChildren.isEmpty()) {
// Some error occurred (most probably while reloading the children)
return null;
}
return allChildren.getLast();
} else {
return lastChild();
}
// </ScaleDOM>
} // 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
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
// <ScaleDOM>
if(isScaleDomEnabled()) {
final LinkedList<ChildNode> allChildren = getAllChildNodes();
if (allChildren.isEmpty()) {
// this our first and only child
allChildren.add(newInternal);
} else {
if (refInternal == null) {
// this is an append
final ChildNode lastChild = allChildren.getLast();
lastChild.nextSibling = newInternal;
newInternal.previousSibling = lastChild;
allChildren.add(newInternal);
} else {
// this is an insert
final ChildNode prev = refInternal.previousSibling;
refInternal.previousSibling = newInternal;
if (prev != null) {
prev.nextSibling = newInternal;
}
newInternal.previousSibling = prev;
newInternal.nextSibling = refInternal;
allChildren.add(allChildren.indexOf(refInternal), newInternal);
}
}
} else {
// 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;
}
}
}
}
// </ScaleDOM>
changed();
// <ScaleDOM>
if(!isScaleDomEnabled()) {
// 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;
}
}
}
}
// </ScaleDOM>
// 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);
// <ScaleDOM>
if(!isScaleDomEnabled()) {
// 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;
}
}
}
}
// </ScaleDOM>
// Patch linked list around oldChild
// <ScaleDOM>
if(isScaleDomEnabled()) {
final LinkedList<ChildNode> allChildren = getAllChildNodes();
final ChildNode prev = oldInternal.previousSibling;
final ChildNode next = oldInternal.nextSibling;
if (prev != null) {
prev.nextSibling = next;
}
if (next != null) {
next.previousSibling = prev;
}
allChildren.remove(oldInternal);
} else {
// 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;
}
}
}
// </ScaleDOM>
// 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() : "";
}
StringBuffer buf = new StringBuffer();
getTextContent(buf);
return buf.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) {
if (needsSyncChildren()) {
synchronizeChildren();
}
// 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() {
// <ScaleDOM>
if(isScaleDomEnabled()) {
return numberOfChildren;
} else {
return nodeListGetLength();
}
// </ScaleDOM>
}
/**
* 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) {
if (needsSyncChildren()) {
synchronizeChildren();
}
// 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) {
// <ScaleDOM>
if(isScaleDomEnabled()) {
return getChildNodes().item(index);
} else {
return nodeListItem(index);
}
// </ScaleDOM>
} // 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.
*
* <ScaleDOM> Note: Only loaded child nodes are normalized. </ScaleDOM>
*/
public void normalize() {
// No need to normalize if already normalized.
if (isNormalized()) {
return;
}
if (needsSyncChildren()) {
synchronizeChildren();
}
ChildNode kid;
// <ScaleDOM>
ChildNode firstChild = null;
if(isScaleDomEnabled()) {
firstChild = getFirstLoadedChildNode();
} else {
firstChild = this.firstChild;
}
// </ScaleDOM>
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 (!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.
*
* <ScaleDOM> Note: Only loaded child nodes are normalized. </ScaleDOM>
*
* @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
// <ScaleDOM>
ChildNode firstChild = null;
if(isScaleDomEnabled()) {
firstChild = getFirstLoadedChildNode();
} else {
firstChild = this.firstChild;
}
// </ScaleDOM>
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
*/
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;
}
}
// <ScaleDOM>
/**
* Returns the node's location within the document source.
*
* @return the node's location information.
*/
public NodeLocation getNodeLocation() {
return location;
}
/**
* Sets the node's location within the document source.<br/>
* Note: This could be done in the constructor, however, every derived class would have to be adapted, which is why
* we use this setter instead.
*
* @param location the node's location information.
*/
public void setNodeLocation(final NodeLocation location) {
this.location = location;
}
/**
* Called by <code>LoadProcess</code> component for each parsed child (so that every parent knows if and how many
* direct children belong to him).
*/
public void parsedChild() {
++numberOfChildren;
}
/**
* Called by <code>LoadProcess</code> component for each parsed namespace declaration on this node. Required for
* correctly reloading a node from the document source.
*
* @param namespace the parsed namespace declaration.
*/
public void parsedNamespace(final Namespace namespace) {
namespaces.add(namespace);
}
/**
* Called by <code>LoadProcess</code> component in order to obtain all effective namespaces of the node to be
* reloaded.
*
* @return list of declared namespaces (on this node only), or an empty list if no namespace declaration exists.
*/
public List<Namespace> getDeclaredNamespaces() {
return namespaces;
}
/**
* Returns the currently loaded list of children.
*
* @return the currently loaded list of children or an empty list if none are loaded or this node has no children.
*/
public LinkedList<ChildNode> getLoadedChildNodes() {
return getChildren(false);
}
/**
* Returns, if loaded, the first child of this node.
*
* @return the first child of this node or null if the first child is not loaded or this node has no children.
*/
protected ChildNode getFirstLoadedChildNode() {
final LinkedList<ChildNode> loadedChildren = getLoadedChildNodes();
if (loadedChildren.isEmpty()) {
return null;
}
return loadedChildren.getFirst();
}
/**
* Returns all children of this node. Reloads them if not currently loaded.
*
* @return all children of this node.
*/
private LinkedList<ChildNode> getAllChildNodes() {
return getChildren(true);
}
private LinkedList<ChildNode> getChildren(final boolean reload) {
LinkedList<ChildNode> loadedChildren = children.get();
if (loadedChildren == null) {
loadedChildren = new LinkedList<ChildNode>();
final ScaleDomDocument doc = (ScaleDomDocument) ownerDocument;
children = new WeakChildNodeList(doc, this, loadedChildren);
if (reload && !doc.isLoading() && hasChildNodes()) {
// Some outside user wants to access not-loaded children => load them
if (this != doc) {
// Load an Element node
numberOfChildren = 0; // will be increased during the reload
doc.load(this);
} else {
// Performance improvement for loading the Document node
loadedChildren.add((ChildNode) doc.getDocumentElement());
log.error("Document node should never be unloaded...");
}
}
}
return loadedChildren;
}
// </ScaleDOM>
} // class ParentNode