package org.eclipse.jdt.internal.core.builder.impl;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import org.eclipse.jdt.internal.core.Assert;
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
import org.eclipse.jdt.internal.core.builder.*;
import org.eclipse.jdt.internal.core.Util;
import java.util.*;
class DeltaImpl implements IDelta {
protected IDelta fParent;
protected IDelta[] fChildren;
/* Non state specific object */
protected Object fObject;
protected String fName;
protected DeltaKey fKey;
protected StateImpl fNewState;
protected StateImpl fOldState;
protected int fStatus;
protected IImageContext fContext;
/* names for checklist items */
public static final String fgImage = "Image"/*nonNLS*/;
public static final String fgPackageCategory = "Packages"/*nonNLS*/;
public static final String fgTypeCategory = "Types"/*nonNLS*/;
public static final String fgBinaryCategory = "Binaries"/*nonNLS*/;
public static final String fgMethodCategory = "Methods"/*nonNLS*/;
public static final String fgPackage = "Package"/*nonNLS*/;
public static final String fgType = "Type"/*nonNLS*/;
public static final String fgBinary = "Binary"/*nonNLS*/;
public static final String fgMethod = "Method"/*nonNLS*/;
/* convenience structure for delta calculation process */
class DeltaInfo {
PackageInfo[] addedPkgs;
PackageInfo[] removedPkgs;
PackageInfo[] changedPkgs;
};
class PackageInfo {
IPackage pkg;
IType[] addedTypes;
IType[] removedTypes;
IType[] changedTypes;
IType[] changedBinaries;
};
/* shared empty array */
protected static final IDelta[] fgEmptyArray = new IDelta[0];
protected IncrementalImageBuilder fIncrementalBuilder;
static final int PS_CHANGED = 1; // has the principal structure changed?
static final int BIN_CHANGED = 2; // has the binary changed?
/**
* Creates a new root image delta
*/
DeltaImpl(IncrementalImageBuilder builder, IImageContext context) {
this(builder.getOldState(), builder.getNewState(), context, builder);
}
/**
* Creates a new root image delta
*/
protected DeltaImpl(StateImpl oldState, StateImpl newState, String name,
Object o, DeltaKey key, IDelta parent, int status) {
fNewState = (StateImpl)newState;
fOldState = (StateImpl)oldState;
fName = name;
fObject = o;
fParent = parent;
fKey = key;
fStatus = status;
fChildren = fgEmptyArray;
fContext = parent.getImageContext();
}
/**
* Creates a new root image delta
*/
DeltaImpl(IState oldState, IState newState, IImageContext context) {
this(oldState, newState, context, null);
}
/**
* Creates a new root image delta
*/
DeltaImpl(IState oldState, IState newState, IImageContext context, IncrementalImageBuilder builder) {
try {
fNewState = (StateImpl)newState;
fOldState = (StateImpl)oldState;
} catch (ClassCastException cce) {
Assert.isTrue(false, "Internal Error - Invalid states"/*nonNLS*/);
}
fStatus = CHANGED;
fName = fgImage;
fObject = newState.getDevelopmentContext().getImage();
fParent = null;
fKey = DeltaKey.getRoot();
fContext = context;
fChildren = fgEmptyArray;
fIncrementalBuilder = builder;
computeImageDelta();
}
/**
* Creates and returns a child with the given name and object
*/
protected DeltaImpl add(String name, Object object, int status) {
return add(name, object, getKey().add(object), status);
}
/**
* Creates and returns a child with the given name and object
*/
protected DeltaImpl add(String name, Object object, DeltaKey key, int status) {
return new DeltaImpl(
fOldState, fNewState, //same states as me
name, object, key, //given name, object and key
this, //parent
status); //added, removed, or changed
}
/**
* Returns the child of this delta with the given object
*/
protected IDelta at(Object o) {
if (fChildren != null){
for (int i = 0; i < fChildren.length; i++) {
if (o instanceof String) {
if (o.equals(fChildren[i].getName())) {
return fChildren[i];
}
}
else {
if (o.equals(fChildren[i].getObject())) {
return fChildren[i];
}
}
}
}
/* not found */
return null;
}
/**
* Compares the type in the old and new states.
* Returns a bit mask indicating whether the principal structure or binary have changed.
*/
protected int compareBuilderType(BuilderType type) {
if (!type.isAffected()) {
return 0;
}
TypeStructureEntry oldEntry = type.getOldTypeStructureEntry();
TypeStructureEntry newEntry = type.getNewTypeStructureEntry();
if (oldEntry == null || newEntry == null) {
return PS_CHANGED | BIN_CHANGED;
}
if (oldEntry == newEntry) {
return 0;
}
int result = 0;
IBinaryType oldType = type.getOldBinaryType();
IBinaryType newType = type.getNewBinaryType();
if (!BinaryStructure.compare(oldType, newType)) {
result |= PS_CHANGED;
}
/*
* If the source entry has changed, consider the binary to have changed
* even if the binary is actually the same. Some clients, such as the
* target manager, need to know when the source changes.
*/
if (!oldEntry.getSourceEntry().equals(newEntry.getSourceEntry())) {
result |= BIN_CHANGED;
} else
if (oldEntry.getCRC32() != newEntry.getCRC32()) {
result |= BIN_CHANGED;
} else {
boolean oldIsBinary = oldEntry.isBinary();
boolean newIsBinary = newEntry.isBinary();
if (oldIsBinary != newIsBinary) {
result |= BIN_CHANGED;
}
}
return result;
}
/**
* Returns an integer indicating whether anotherDelta is less than, equal to,
* or greater than this delta.
*/
public int compareTo(IDelta anotherDelta) {
/* is this used? */
Assert.isTrue(false, "TBD"/*nonNLS*/);
return 0;
}
/**
* Compares the type in the old and new states.
* Returns a bit mask indicating whether the principal structure or binary have changed.
*/
protected int compareTypes(IType handle) {
if (fIncrementalBuilder != null) {
return compareBuilderType(fIncrementalBuilder.getBuilderType(handle));
}
TypeStructureEntry oldEntry = fOldState.getTypeStructureEntry(handle, true);
TypeStructureEntry newEntry = fNewState.getTypeStructureEntry(handle, true);
if (oldEntry == null || newEntry == null) {
return PS_CHANGED | BIN_CHANGED;
}
if (oldEntry == newEntry) {
return 0;
}
int result = 0;
IBinaryType oldType = fOldState.getBinaryType(oldEntry);
IBinaryType newType = fNewState.getBinaryType(newEntry);
if (!BinaryStructure.compare(oldType, newType)) {
result |= PS_CHANGED;
}
/*
* If the source entry has changed, consider the binary to have changed
* even if the binary is actually the same. Some clients, such as the
* target manager, need to know when the source changes.
*/
if (!oldEntry.getSourceEntry().equals(newEntry.getSourceEntry())) {
result |= BIN_CHANGED;
} else
if (oldEntry.getCRC32() != newEntry.getCRC32()) {
result |= BIN_CHANGED;
} else {
boolean oldIsBinary = oldEntry.isBinary();
boolean newIsBinary = newEntry.isBinary();
if (oldIsBinary != newIsBinary) {
result |= BIN_CHANGED;
}
}
return result;
}
/**
* Computes the added classes for each added package.
* Returns a DeltaInfo object for each package describing the affected
* classes.
*/
protected PackageInfo[] computeAddedClasses(Vector pkgs) {
PackageInfo[] infos = new PackageInfo[pkgs.size()];
int i = 0;
for (Enumeration pkgEnum = pkgs.elements(); pkgEnum.hasMoreElements(); i++) {
IPackage pkg = (IPackage) pkgEnum.nextElement();
infos[i] = new PackageInfo();
infos[i].pkg = pkg;
IType[] types = ((IPackage) pkg.inState(fNewState)).getAllClasses();
for (int j = 0; j < types.length; ++j) {
types[j] = (IType) types[j].nonStateSpecific();
}
infos[i].addedTypes = types;
}//next package
return infos;
}//end function
/**
* Computes added, removed, and changed classes for a set of packages.
* Stores vectors of IType handles.
*/
protected void computeAllClasses(IPackage pkg,
Vector added, Vector removed, Vector changedTypes, Vector changedBinaries) {
/* collect a set of all classes in old package */
/* we have to make a copy here to avoid destroying the state */
Hashtable oldTypeTable = new Hashtable();
IType[] oldTypes = ((IPackage) pkg.inState(fOldState)).getAllClasses();
for (int i = 0; i < oldTypes.length; i++) {
IType handle = (IType)oldTypes[i].nonStateSpecific();
oldTypeTable.put(handle, handle);
}
/* iterate through new classes */
IType[] newTypes = ((IPackage)pkg.inState(fNewState)).getAllClasses();
for (int i = 0; i < newTypes.length; i++) {
IType handle = (IType)newTypes[i].nonStateSpecific();
if (oldTypeTable.remove(handle) != null) {
/* class is in both packages */
int code = compareTypes(handle);
if ((code & PS_CHANGED) != 0) {
changedTypes.addElement(handle);
}
if ((code & BIN_CHANGED) != 0) {
changedBinaries.addElement(handle);
}
} else {
/* its only in the new package */
added.addElement(handle);
}
}
/* remaining classes are removed */
for (Enumeration e = oldTypeTable.keys(); e.hasMoreElements();) {
removed.addElement(e.nextElement());
}
}
/**
* Computes added, removed, and changed packages. At this
* stage, if a package hasn't been added or removed, it is
* considered to be changed. Later, when the classes are
* calculated, the packages that don't have changed classes
* will be removed from the list. Stores vectors of non-state
* specific package handles.
*/
protected void computeAllPackages(
Vector added, Vector removed, Vector changed) {
/* do for each affected package */
for (Enumeration e = getAffectedPackages();e.hasMoreElements();) {
IPackage pkg = (IPackage)e.nextElement();
boolean inOld = pkg.inState(fOldState).isPresent();
boolean inNew = pkg.inState(fNewState).isPresent();
if (inOld) {
if (inNew) {
changed.addElement(pkg);
}
else {
// Package was removed.
removed.addElement(pkg);
}
}
else {
if (inNew) {
// Package was added.
added.addElement(pkg);
}
else {
// Package was in image context but was not in either state.
// Ignore it.
}
}
}
}
/**
* Computes added, removed, and changed classes for a set of packages.
* Returns a DeltaInfo object for each package describing the affected
* classes.
*/
protected PackageInfo[] computeChangedClasses(Vector pkgs) {
Vector vInfo = new Vector();
Vector toRemove = new Vector();
for (Enumeration pkgEnum = pkgs.elements(); pkgEnum.hasMoreElements();) {
IPackage pkg = (IPackage)pkgEnum.nextElement();
Vector vAdded = new Vector();
Vector vRemoved = new Vector();
Vector vChanged = new Vector();
Vector vBinaries = new Vector();
computeAllClasses(pkg, vAdded, vRemoved, vChanged, vBinaries);
/* if there are any affected classes */
if (vAdded.size() + vRemoved.size() + vChanged.size() + vBinaries.size() > 0) {
/* fill out package information */
PackageInfo pkgInfo = new PackageInfo();
pkgInfo.pkg = pkg;
pkgInfo.addedTypes = new IType[vAdded.size()];
vAdded.copyInto(pkgInfo.addedTypes);
pkgInfo.removedTypes = new IType[vRemoved.size()];
vRemoved.copyInto(pkgInfo.removedTypes);
pkgInfo.changedTypes = new IType[vChanged.size()];
vChanged.copyInto(pkgInfo.changedTypes);
pkgInfo.changedBinaries = new IType[vBinaries.size()];
vBinaries.copyInto(pkgInfo.changedBinaries);
vInfo.addElement(pkgInfo);
} else {
/* remove the element -- can't delete while enumerating */
toRemove.addElement(pkg);
}
}//next package
/* remove packages with no changes */
for (Enumeration e = toRemove.elements(); e.hasMoreElements();) {
pkgs.removeElement(e.nextElement());
}
/* convert info vector to array */
PackageInfo[] infos = new PackageInfo[vInfo.size()];
vInfo.copyInto(infos);
return infos;
}//end function
/**
* Calculates the added, removed, and changed packages, types and methods
* that consitute an image delta. The results are stored in the supplied
* DeltaInfo object
*/
protected DeltaInfo computeDeltaInfo() {
DeltaInfo info = new DeltaInfo();
/* compute packages */
Vector vAddedPkgs = new Vector();
Vector vRemovedPkgs = new Vector();
Vector vChangedPkgs = new Vector();
computeAllPackages(vAddedPkgs, vRemovedPkgs, vChangedPkgs);
/* compute classes */
info.addedPkgs = computeAddedClasses(vAddedPkgs);
info.removedPkgs = computeRemovedClasses(vRemovedPkgs);
info.changedPkgs = computeChangedClasses(vChangedPkgs);
return info;
}
/**
* Computes the image delta.
*/
protected void computeImageDelta() {
/* compute the delta info */
DeltaInfo info = computeDeltaInfo();
/* create categories, any or all of them may be null */
IDelta pkgCategory = createPackageCategory(this, info);
IDelta typeCategory = createCategory(this, info, fgTypeCategory);
IDelta binaryCategory = createCategory(this, info, fgBinaryCategory);
/* Create top level children */
int childCount = 0;
if (pkgCategory != null) childCount++;
if (typeCategory != null) childCount++;
if (binaryCategory != null) childCount++;
fChildren = new IDelta[childCount];
childCount = 0;
if (pkgCategory != null)
fChildren[childCount++] = pkgCategory;
if (typeCategory != null)
fChildren[childCount++] = typeCategory;
if (binaryCategory != null)
fChildren[childCount++] = binaryCategory;
}
/**
* Computes the removed classes for each removed package.
* Returns a DeltaInfo object for each package describing the affected
* classes.
*/
protected PackageInfo[] computeRemovedClasses(Vector pkgs) {
PackageInfo[] infos = new PackageInfo[pkgs.size()];
int i = 0;
for (Enumeration pkgEnum = pkgs.elements(); pkgEnum.hasMoreElements(); i++) {
IPackage pkg = (IPackage) pkgEnum.nextElement();
infos[i] = new PackageInfo();
infos[i].pkg = pkg;
IType[] types = ((IPackage) pkg.inState(fOldState)).getAllClasses();
for (int j = 0; j < types.length; ++j) {
types[j] = (IType) types[j].nonStateSpecific();
}
infos[i].removedTypes = types;
}//next package
return infos;
}//end function
/**
* Converts a vector of handles to an array of delta info objects of the given
* type.
*/
protected IDelta[] convertHandlesToDeltaArray(Vector vHandles, String type, int status) {
int i = 0;
IDelta[] results = new IDelta[vHandles.size()];
for (Enumeration e = vHandles.elements(); e.hasMoreElements(); i++) {
results[i] = add(type, e.nextElement(), status);
}
return results;
}
/**
* Copies information from a PackageInfo to the children of a DeltaImpl.
* If types is true, copy the type information, otherwise copy the binary information
*/
protected void copyInfoToChildren(DeltaImpl delta, PackageInfo info, boolean types) {
/* are we looking at binaries or types ? */
IType[] changed = types ? info.changedTypes : info.changedBinaries;
String name = types ? fgType : fgBinary;
int count = info.addedTypes.length + info.removedTypes.length + changed.length;
if (count == 0) {
delta.fStatus = SAME;
delta.setChildren(new IDelta[0]);
return;
}
IDelta[] children = new IDelta[count];
int i = 0;
for (; i < info.addedTypes.length; i++) {
children[i] = delta.add(name, info.addedTypes[i], ADDED);
}
for (int j = 0; j < info.removedTypes.length; j++, i++) {
children[i] = delta.add(name, info.removedTypes[j], REMOVED);
}
for (int j = 0; j < changed.length; j++, i++) {
children[i] = delta.add(name, changed[j], CHANGED);
}
delta.setChildren(children);
}
/**
* Creates the types category of the image delta. Returns
* the Delta object for the category. If there are no added,
* removed, or changed types, returns null.
*/
protected IDelta createCategory(DeltaImpl parent, DeltaInfo info, String categoryName) {
int size = info.changedPkgs.length + info.addedPkgs.length + info.removedPkgs.length;
if (size == 0) return null;
/* collection of packages that are children of the type category */
IDelta[] children = new IDelta[size];
/* create Type category node */
DeltaImpl category = parent.add(categoryName, parent.getObject(), parent.getKey().add(categoryName), CHANGED);
/* create new deltas for changed packages */
int count = 0;
for (int i = 0; i < info.changedPkgs.length; i++) {
PackageInfo pkgInfo = info.changedPkgs[i];
DeltaImpl child = (DeltaImpl)category.add(fgPackage, pkgInfo.pkg, CHANGED);
copyInfoToChildren(child, pkgInfo, categoryName == fgTypeCategory);
children[count++] = child;
}
/* create deltas for added and removed packages */
for (int i = 0; i < info.addedPkgs.length; i++) {
children[count++] = category.packageForTypeCategory(ADDED, info.addedPkgs[i]);
}
for (int i = 0; i < info.removedPkgs.length; i++) {
children[count++] = category.packageForTypeCategory(REMOVED, info.removedPkgs[i]);
}
category.setChildren(children);
return category;
}
/**
* Creates the package category of the image delta. Returns
* the Delta object for the category. If there are no added,
* removed, or changed packages, returns null. A changed package
* is a package that has had a package fragment added or removed.
*/
protected IDelta createPackageCategory(DeltaImpl parent, DeltaInfo info) {
/* number of children of this category */
int size = info.addedPkgs.length + info.changedPkgs.length + info.removedPkgs.length;
if (size == 0) return null;
/* create the category */
DeltaImpl category =
parent.add(
fgPackageCategory,
parent.getObject(),
parent.getKey().add(fgPackageCategory),
CHANGED);
IDelta[] children = new IDelta[size];
int count = 0;
for (int i = 0; i < info.addedPkgs.length; i++) {
children[count++] = category.add(fgPackage, info.addedPkgs[i].pkg, ADDED);
}
for (int i = 0; i < info.removedPkgs.length; i++) {
children[count++] = category.add(fgPackage, info.removedPkgs[i].pkg, REMOVED);
}
for (int i = 0; i < info.changedPkgs.length; i++) {
IPackage pkg = info.changedPkgs[i].pkg;
if (!Util.equalArraysOrNull(
fOldState.getPackageMap().getFragments(pkg),
fNewState.getPackageMap().getFragments(pkg))) {
children[count++] = category.add(fgPackage, pkg, CHANGED);
}
}
/* there could be no changed packages */
if (count == 0) {
return null;
}
/* compact if some changed packages did not actually change */
if (count < children.length) {
System.arraycopy(children, 0, children = new IDelta[count], 0, count);
}
category.setChildren(children);
return category;
}
public void dump() {
dump(this, 0);
}
protected static void dump(IDelta delta, int depth) {
for (int i = 0; i < depth; ++i)
System.out.print(" "/*nonNLS*/);
System.out.println(delta);
IDelta[] children = delta.getAffectedSubdeltas();
for (int i = 0; i < children.length; ++i) {
dump(children[i], depth+1);
}
}
/**
* Returns the delta reached by navigating the given
* relative path from this object.
* It is an error if the delta could never have such a descendent.
* <pre>
* - navigation off a checklist with the wrong child name
* is always bad
* - navigation off a batch delta is common when you don't
* yet know whether the object is present; this is allowed
* - navigation off a leaf delta is always bad
* </pre>
*
* @param path the path to follow
* @exception InvalidKeyException if an invalid key is given.
*/
public IDelta follow(IDeltaKey path) throws InvalidKeyException {
IDelta delta = this;
for (int i = 0, size = path.size(); i < size; ++i) {
delta = ((DeltaImpl) delta).at(path.at(i));
if (delta == null) {
throw new InvalidKeyException();
}
}
return delta;
}
/**
* Returns the immediate subdeltas of this delta that are additions
* (i.e. their status is Added).
*/
public IDelta[] getAddedSubdeltas() {
if (fChildren == null) return fgEmptyArray;
Vector vAdded = new Vector();
for (int i = 0; i < fChildren.length; i++) {
if (fChildren[i].getStatus() == IDelta.ADDED) {
vAdded.addElement(fChildren[i]);
}
}
IDelta[] added = new IDelta[vAdded.size()];
vAdded.copyInto(added);
return added;
}
/**
* Returns an enumeration of packages which are possibly affected.
*/
public Enumeration getAffectedPackages() {
/* Non-naive case - the image builder knows. */
if (fIncrementalBuilder != null) {
return fIncrementalBuilder.getAffectedPackages();
}
/* Naive case - take union of packages in old and new state. */
Hashtable affected = new Hashtable(21);
for (Enumeration e = fOldState.getPackageMap().getAllPackages(); e.hasMoreElements();) {
IPackage pkg = (IPackage) e.nextElement();
affected.put(pkg, pkg);
}
for (Enumeration e = fNewState.getPackageMap().getAllPackages(); e.hasMoreElements();) {
IPackage pkg = (IPackage) e.nextElement();
affected.put(pkg, pkg);
}
return affected.keys();
}
/**
* Returns the immediate subdeltas of this delta that are
* not the same (i.e. their status is either Added, Removed, or Changed).
*/
public IDelta[] getAffectedSubdeltas() {
if (fChildren == null) return fgEmptyArray;
Vector vAffected = new Vector();
for (int i = 0; i < fChildren.length; i++) {
if (fChildren[i].getStatus() != IDelta.SAME) {
vAffected.addElement(fChildren[i]);
}
}
IDelta[] affected = new IDelta[vAffected.size()];
vAffected.copyInto(affected);
return affected;
}
/**
* Returns the immediate subdeltas of this delta that are true
* changes, not additions or removals (i.e. their status is Changed).
*/
public IDelta[] getChangedSubdeltas() {
if (fChildren == null) return fgEmptyArray;
Vector vChanged = new Vector();
for (int i = 0; i < fChildren.length; i++) {
if (fChildren[i].getStatus() == IDelta.CHANGED) {
vChanged.addElement(fChildren[i]);
}
}
IDelta[] changed = new IDelta[vChanged.size()];
vChanged.copyInto(changed);
return changed;
}
/**
* Returns the ImageContext that the delta is restricted to.
*
* @see IImageBuilder#getImageDelta
*/
public IImageContext getImageContext() {
return fContext;
}
/**
* Returns the delta key for this delta.
* Delta keys often contain non-state-specific handles, but
* never state-specific ones.
*
* @see DeltaKey
*/
public IDeltaKey getKey() {
return fKey;
}
/**
* Returns the name of the aspect being compared in this delta.
*/
public String getName() {
return fName;
}
/**
* Returns the object in the new state that is the focus of this delta.
* It only make sense to talk about the 'new object' if the object
* that is the focus of this delta is a Handle. If it is not, this
* returns null.
*
* @return the state-specific handle of the object in the new state.
*/
public IHandle getNewObject() {
IHandle handle;
try {
handle = (IHandle)fObject;
} catch (ClassCastException cce) {
//not a handle
return null;
}
return handle.inState(fNewState);
}
/**
* Returns the new state to which this delta pertains.
*/
public IState getNewState() {
return fNewState;
}
/**
* Returns the object that is the focus of this delta.
* The result is often a Handle, but in
* some cases it is another type of object.
* When it is a Handle, it is non-state-specific.
*/
public Object getObject() {
return fObject;
}
/**
* Returns the object in the old state that is the focus of this delta.
* It only make sense to talk about the 'old object' if the object
* that is the focus of this delta is a Handle. If it is not, this
* returns null.
*
* @return the state-specific handle of the object in the old state.
*/
public IHandle getOldObject() {
IHandle handle;
try {
handle = (IHandle)fObject;
} catch (ClassCastException cce) {
//not a handle
return null;
}
return handle.inState(fOldState);
}
/**
* Returns the old state to which this delta pertains.
*/
public org.eclipse.jdt.internal.core.builder.IState getOldState() {
return fOldState;
}
/**
* Returns the parent delta of this delta, or null if it has no parent.
*/
public IDelta getParent() {
return fParent;
}
/**
* Returns the immediate subdeltas of this delta that are removals
* (i.e. their status is Removed).
*/
public IDelta[] getRemovedSubdeltas() {
if (fChildren == null) return fgEmptyArray;
Vector vRemoved = new Vector();
for (int i = 0; i < fChildren.length; i++) {
if (fChildren[i].getStatus() == IDelta.REMOVED) {
vRemoved.addElement(fChildren[i]);
}
}
IDelta[] removed = new IDelta[vRemoved.size()];
vRemoved.copyInto(removed);
return removed;
}
/**
* Returns the root delta of the tree containing this delta.
*/
public IDelta getRoot() {
/* don't bother caching the root at each branch for now */
if (fKey == DeltaKey.getRoot()) {
return this;
} else {
return getParent().getRoot();
}
}
/**
* Returns the status of this delta. If this delta
* is not applicable, it always returns SAME.
* If the status is not currently known, it is computed
* (UNKNOWN is never returned).
*/
public int getStatus() {
return fStatus;
}
/**
* Returns the status of this delta if it is known.
* Returns UNKNOWN if it is not known whether the object has changed.
*
*/
public int getStatusIfKnown() {
return fStatus;
}
/**
* Returns an array of Delta objects that are children of this delta.
* Returns an array of length 0 if this delta has no children,
* or if it is not composite.
*/
public IDelta[] getSubdeltas() {
return fChildren;
}
/**
* Returns whether this delta is a composite delta that is further
* broken down into subdeltas.
*/
public boolean hasSubdeltas() {
return fChildren != null && fChildren.length > 0;
}
/**
* Creates a package delta for the types or binaries category.
* The package delta can be for either an added or removed package,
* according to the constant given. The package delta will have
* children for each type in the package.
*/
protected IDelta packageForTypeCategory(int status, PackageInfo info) {
/* create the package delta */
DeltaImpl pkgDelta = (DeltaImpl)this.add(fgPackage, info.pkg, status);
IType[] types = (status == ADDED ? info.addedTypes : info.removedTypes);
IDelta[] children = new IDelta[types.length];
for (int i = 0; i < types.length; i++) {
children[i] = pkgDelta.add(fgType, types[i], status);
}
pkgDelta.setChildren(children);
return pkgDelta;
}
/**
* Sets the children of this delta
*/
protected void setChildren(IDelta[] children) {
fChildren = children;
}
/**
* Return a string of the form:
* status key
*
* status will be one of the following:
* + if status is ADDED
* - if status is REMOVED
* * if status is CHANGED
* = if status is SAME
* ? if status is UNKNOWN
* The string returned is only for debugging purposes,
* and the contents of the string may change in the future.
* @return java.lang.String
*/
public String toString() {
StringBuffer sb = new StringBuffer("DeltaImpl("/*nonNLS*/);
switch (fStatus) {
case ADDED: sb.append("+"/*nonNLS*/);
break;
case REMOVED: sb.append("-"/*nonNLS*/);
break;
case CHANGED: sb.append("*"/*nonNLS*/);
break;
case SAME: sb.append("="/*nonNLS*/);
break;
case UNKNOWN: sb.append("?"/*nonNLS*/);
break;
default: sb.append("(ERROR)"/*nonNLS*/);
}
if (fKey.isRoot()) {
sb.append(fOldState);
sb.append("-->"/*nonNLS*/);
sb.append(fNewState);
}
else {
for (int i = 0; i < fKey.size(); ++i) {
if (i != 0) {
sb.append('/');
}
sb.append(fKey.at(i));
}
}
sb.append(')');
return sb.toString();
}
}
