/*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.internal.dtree;
import org.eclipse.core.internal.utils.*;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
/**
* <code>DataTreeNode</code>s are the nodes of a <code>DataTree</code>. Their information and their
* subtrees are complete, and do not represent deltas on another node or subtree.
*/
public class DataTreeNode extends AbstractDataTreeNode {
protected Object data;
/**
* Creates a new node
*
* @param name name of node
* @param data data for node
*/
public DataTreeNode(String name, Object data) {
super(name, AbstractDataTreeNode.NO_CHILDREN);
this.data= data;
}
/**
* Creates a new node
*
* @param name name of node
* @param data data for node
* @param children children for new node
*/
public DataTreeNode(String name, Object data, AbstractDataTreeNode[] children) {
super(name, children);
this.data= data;
}
/**
* @see AbstractDataTreeNode#asBackwardDelta(DeltaDataTree, DeltaDataTree, IPath)
*/
AbstractDataTreeNode asBackwardDelta(DeltaDataTree myTree, DeltaDataTree parentTree, IPath key) {
if (parentTree.includes(key))
return parentTree.copyCompleteSubtree(key);
return new DeletedNode(name);
}
/**
* If this node is a node in a comparison tree, this method reverses the comparison for this
* node and all children. Returns null if this node should no longer be included in the
* comparison tree.
*/
AbstractDataTreeNode asReverseComparisonNode(IComparator comparator) {
NodeComparison comparison= null;
try {
comparison= ((NodeComparison)data).asReverseComparison(comparator);
} catch (ClassCastException e) {
Assert.isTrue(false, Messages.dtree_reverse);
}
int nextChild= 0;
for (int i= 0; i < children.length; i++) {
AbstractDataTreeNode child= children[i].asReverseComparisonNode(comparator);
if (child != null) {
children[nextChild++]= child;
}
}
if (nextChild == 0 && comparison.getUserComparison() == 0) {
/* no children and no change */
return null;
}
/* set the new data */
data= comparison;
/* shrink child array as necessary */
if (nextChild < children.length) {
AbstractDataTreeNode[] newChildren= new AbstractDataTreeNode[nextChild];
System.arraycopy(children, 0, newChildren, 0, nextChild);
children= newChildren;
}
return this;
}
AbstractDataTreeNode compareWith(DataTreeNode other, IComparator comparator) {
AbstractDataTreeNode[] comparedChildren= compareWith(children, other.children, comparator);
Object oldData= data;
Object newData= other.data;
/* don't allow comparison of implicit root node */
int userComparison= 0;
if (name != null) {
userComparison= comparator.compare(oldData, newData);
}
return new DataTreeNode(name, new NodeComparison(oldData, newData, NodeComparison.K_CHANGED, userComparison), comparedChildren);
}
AbstractDataTreeNode compareWithParent(IPath key, DeltaDataTree parent, IComparator comparator) {
if (!parent.includes(key))
return convertToAddedComparisonNode(this, NodeComparison.K_ADDED);
DataTreeNode inParent= (DataTreeNode)parent.copyCompleteSubtree(key);
return inParent.compareWith(this, comparator);
}
/**
* Creates and returns a new copy of the receiver.
*/
AbstractDataTreeNode copy() {
if (children.length > 0) {
AbstractDataTreeNode[] childrenCopy= new AbstractDataTreeNode[children.length];
System.arraycopy(children, 0, childrenCopy, 0, children.length);
return new DataTreeNode(name, data, childrenCopy);
}
return new DataTreeNode(name, data, children);
}
/**
* Returns a new node containing a child with the given local name in addition to the receiver's
* current children and data.
*
* @param localName name of new child
* @param childNode new child node
*/
DataTreeNode copyWithNewChild(String localName, DataTreeNode childNode) {
AbstractDataTreeNode[] children= this.children;
int left= 0;
int right= children.length - 1;
while (left <= right) {
int mid= (left + right) / 2;
int compare= localName.compareTo(children[mid].name);
if (compare < 0) {
right= mid - 1;
} else if (compare > 0) {
left= mid + 1;
} else {
throw new Error(); // it shouldn't have been here yet
}
}
AbstractDataTreeNode[] newChildren= new AbstractDataTreeNode[children.length + 1];
System.arraycopy(children, 0, newChildren, 0, left);
childNode.setName(localName);
newChildren[left]= childNode;
System.arraycopy(children, left, newChildren, left + 1, children.length - left);
return new DataTreeNode(this.getName(), this.getData(), newChildren);
}
/**
* Returns a new node without the specified child, but with the rest of the receiver's current
* children and its data.
*
* @param localName name of child to exclude
*/
DataTreeNode copyWithoutChild(String localName) {
int index, newSize;
DataTreeNode newNode;
AbstractDataTreeNode children[];
index= this.indexOfChild(localName);
if (index == -1) {
newNode= (DataTreeNode)this.copy();
} else {
newSize= this.size() - 1;
children= new AbstractDataTreeNode[newSize];
newNode= new DataTreeNode(this.getName(), this.getData(), children);
newNode.copyChildren(0, index - 1, this, 0); //#from:to:with:startingAt:
newNode.copyChildren(index, newSize - 1, this, index + 1);
}
return newNode;
}
/**
* Returns an array of delta nodes representing the forward delta between the given two lists of
* nodes. The given nodes must all be complete nodes.
*/
protected static AbstractDataTreeNode[] forwardDeltaWith(AbstractDataTreeNode[] oldNodes, AbstractDataTreeNode[] newNodes, IComparator comparer) {
if (oldNodes.length == 0 && newNodes.length == 0) {
return NO_CHILDREN;
}
AbstractDataTreeNode[] childDeltas= null;
int numChildDeltas= 0;
int childDeltaMax= 0;
// do a merge
int oldIndex= 0;
int newIndex= 0;
while (oldIndex < oldNodes.length && newIndex < newNodes.length) {
String oldName= oldNodes[oldIndex].name;
String newName= newNodes[newIndex].name;
int compare= oldName.compareTo(newName);
if (compare == 0) {
AbstractDataTreeNode deltaNode= forwardDeltaWithOrNullIfEqual(oldNodes[oldIndex++], newNodes[newIndex++], comparer);
if (deltaNode != null) {
if (numChildDeltas >= childDeltaMax) {
if (childDeltas == null)
childDeltas= new AbstractDataTreeNode[childDeltaMax= 5];
else
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[childDeltaMax= childDeltaMax * 2 + 1], 0, numChildDeltas);
}
childDeltas[numChildDeltas++]= deltaNode;
}
} else if (compare < 0) {
if (numChildDeltas >= childDeltaMax) {
if (childDeltas == null)
childDeltas= new AbstractDataTreeNode[childDeltaMax= 5];
else
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[childDeltaMax= childDeltaMax * 2 + 1], 0, numChildDeltas);
}
childDeltas[numChildDeltas++]= new DeletedNode(oldName);
oldIndex++;
} else {
if (numChildDeltas >= childDeltaMax) {
if (childDeltas == null)
childDeltas= new AbstractDataTreeNode[childDeltaMax= 5];
else
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[childDeltaMax= childDeltaMax * 2 + 1], 0, numChildDeltas);
}
childDeltas[numChildDeltas++]= newNodes[newIndex++];
}
}
while (oldIndex < oldNodes.length) {
if (numChildDeltas >= childDeltaMax) {
if (childDeltas == null)
childDeltas= new AbstractDataTreeNode[childDeltaMax= 5];
else
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[childDeltaMax= childDeltaMax * 2 + 1], 0, numChildDeltas);
}
childDeltas[numChildDeltas++]= new DeletedNode(oldNodes[oldIndex++].name);
}
while (newIndex < newNodes.length) {
if (numChildDeltas >= childDeltaMax) {
if (childDeltas == null)
childDeltas= new AbstractDataTreeNode[childDeltaMax= 5];
else
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[childDeltaMax= childDeltaMax * 2 + 1], 0, numChildDeltas);
}
childDeltas[numChildDeltas++]= newNodes[newIndex++];
}
// trim size of result
if (numChildDeltas == 0) {
return NO_CHILDREN;
}
if (numChildDeltas < childDeltaMax) {
System.arraycopy(childDeltas, 0, childDeltas= new AbstractDataTreeNode[numChildDeltas], 0, numChildDeltas);
}
return childDeltas;
}
/**
* Returns a node representing the forward delta between the given two (complete) nodes.
*/
protected AbstractDataTreeNode forwardDeltaWith(DataTreeNode other, IComparator comparer) {
AbstractDataTreeNode deltaNode= forwardDeltaWithOrNullIfEqual(this, other, comparer);
if (deltaNode == null) {
return new NoDataDeltaNode(name, NO_CHILDREN);
}
return deltaNode;
}
/**
* Returns a node representing the forward delta between the given two (complete) nodes, or null
* if the two nodes are equal. Although typed as abstract nodes, the given nodes must be
* complete.
*/
protected static AbstractDataTreeNode forwardDeltaWithOrNullIfEqual(AbstractDataTreeNode oldNode, AbstractDataTreeNode newNode, IComparator comparer) {
AbstractDataTreeNode[] childDeltas= forwardDeltaWith(oldNode.children, newNode.children, comparer);
Object newData= newNode.getData();
if (comparer.compare(oldNode.getData(), newData) == 0) {
if (childDeltas.length == 0) {
return null;
}
return new NoDataDeltaNode(newNode.name, childDeltas);
}
return new DataDeltaNode(newNode.name, newData, childDeltas);
}
/**
* Returns the data for the node
*/
public Object getData() {
return data;
}
/**
* Returns true if the receiver can carry data, false otherwise.
*/
boolean hasData() {
return true;
}
/**
* Sets the data for the node
*/
void setData(Object o) {
data= o;
}
/**
* Simplifies the given node, and answers its replacement.
*/
AbstractDataTreeNode simplifyWithParent(IPath key, DeltaDataTree parent, IComparator comparer) {
/* If not in parent, can't be simplified */
if (!parent.includes(key)) {
return this;
}
/* Can't just call simplify on children since this will miss the case
where a child exists in the parent but does not in this.
See PR 1FH5RYA. */
DataTreeNode parentsNode= (DataTreeNode)parent.copyCompleteSubtree(key);
return parentsNode.forwardDeltaWith(this, comparer);
}
/* (non-Javadoc
* Method declared on IStringPoolParticipant
*/
public void storeStrings(StringPool set) {
super.storeStrings(set);
//copy data for thread safety
Object o= data;
if (o instanceof IStringPoolParticipant)
((IStringPoolParticipant)o).shareStrings(set);
}
/**
* Returns a unicode representation of the node. This method is used for debugging purposes only
* (no NLS support needed)
*/
public String toString() {
return "a DataTreeNode(" + this.getName() + ") with " + getChildren().length + " children."; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
/**
* Returns a constant describing the type of node.
*/
int type() {
return T_COMPLETE_NODE;
}
}