org.eclipse.core.internal.dtree.DataDeltaNode Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation

AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based @AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step. This library is a superset of AspectJ weaver and hence also of AspectJ runtime.

There is a newer version: 1.9.22.1

Show newest version

/*******************************************************************************
 * Copyright (c) 2000, 2014 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.internal.dtree;

import org.eclipse.core.runtime.IPath;

/**
 * A DataDeltaNode contains information that represents the differences
 * between itself and a node in another tree.  Refer to the DeltaDataTree
 * 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)
	 */
	@Override
	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);
	}

	@Override
	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 (!parent.isRoot(key)) {
			/* 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.
	 */
	@Override
	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.
	 */
	@Override
	boolean isDelta() {
		return true;
	}

	/**
	 * Simplifies the given node, and answers its replacement.
	 */
	@Override
	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 constant describing the type of node.
	 */
	@Override
	int type() {
		return T_DELTA_NODE;
	}
}