DataDeltaNode.java

/*******************************************************************************
 * Copyright (c) 2000, 2005 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.runtime.IPath;

/**
 * A <code>DataDeltaNode</code> contains information that represents the differences between itself
 * and a node in another tree. Refer to the <code>DeltaDataTree</code> API and comments for details.
 * 
 * @see DeltaDataTree
 */
public class DataDeltaNode extends DataTreeNode {
	/**
	 * Creates a node with the given name and data, but with no children.
	 */
	DataDeltaNode(String name, Object data) {
		super(name, data);
	}

	/**
	 * Creates a node with the given name, data and children.
	 */
	DataDeltaNode(String name, Object data, AbstractDataTreeNode[] children) {
		super(name, data, children);
	}

	/**
	 * @see AbstractDataTreeNode#asBackwardDelta(DeltaDataTree, DeltaDataTree, IPath)
	 */
	AbstractDataTreeNode asBackwardDelta(DeltaDataTree myTree, DeltaDataTree parentTree, IPath key) {
		AbstractDataTreeNode[] newChildren;
		if (children.length == 0) {
			newChildren= NO_CHILDREN;
		} else {
			newChildren= new AbstractDataTreeNode[children.length];
			for (int i= children.length; --i >= 0;) {
				newChildren[i]= children[i].asBackwardDelta(myTree, parentTree, key.append(children[i].getName()));
			}
		}
		return new DataDeltaNode(name, parentTree.getData(key), newChildren);
	}

	AbstractDataTreeNode compareWithParent(IPath key, DeltaDataTree parent, IComparator comparator) {
		AbstractDataTreeNode[] comparedChildren= compareWithParent(children, key, parent, comparator);
		Object oldData= parent.getData(key);
		Object newData= data;
		/* don't compare data of root */
		int userComparison= 0;
		if (key != parent.rootKey()) {
			/* allow client to specify user comparison bits */
			userComparison= comparator.compare(oldData, newData);
		}
		return new DataTreeNode(key.lastSegment(), new NodeComparison(oldData, newData, NodeComparison.K_CHANGED, userComparison), comparedChildren);
	}

	/**
	 * Creates and returns a new copy of the receiver. Makes a deep copy of children, but a shallow
	 * copy of name and data.
	 */
	AbstractDataTreeNode copy() {
		AbstractDataTreeNode[] childrenCopy;
		if (children.length == 0) {
			childrenCopy= NO_CHILDREN;
		} else {
			childrenCopy= new AbstractDataTreeNode[children.length];
			System.arraycopy(children, 0, childrenCopy, 0, children.length);
		}
		return new DataDeltaNode(name, data, childrenCopy);
	}

	/**
	 * Returns true if the receiver represents delta information, false if it represents the
	 * complete information.
	 */
	boolean isDelta() {
		return true;
	}

	/**
	 * Simplifies the given node, and answers its replacement.
	 */
	AbstractDataTreeNode simplifyWithParent(IPath key, DeltaDataTree parent, IComparator comparer) {
		AbstractDataTreeNode[] simplifiedChildren= simplifyWithParent(children, key, parent, comparer);
		/* don't compare root nodes */
		if (!key.isRoot() && comparer.compare(parent.getData(key), data) == 0)
			return new NoDataDeltaNode(name, simplifiedChildren);
		return new DataDeltaNode(name, data, simplifiedChildren);
	}

	/**
	 * Returns a unicode representation of the node. This method is used for debugging purposes only
	 * (no NLS support needed)
	 */
	public String toString() {
		return "a DataDeltaNode(" + 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_DELTA_NODE;
	}
}