/*******************************************************************************
* Copyright (c) 2000, 2016 QNX Software Systems 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:
* QNX Software Systems - Initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.internal.core.model;
import java.util.ArrayList;
import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICElementDelta;
import org.eclipse.core.resources.IResourceDelta;
/**
* @see ICElementDelta
*/
public class CElementDelta implements ICElementDelta {
/**
* The element that this delta describes the change to.
* @see #getElement()
*/
protected ICElement fChangedElement;
/**
* @see #getKind()
*/
private int fKind = 0;
/**
* @see #getFlags()
*/
private int fChangeFlags = 0;
/**
* @see #getMovedFromElement()
*/
protected ICElement fMovedFromHandle = null;
/**
* @see #getMovedToElement()
*/
protected ICElement fMovedToHandle = null;
/**
* Collection of resource deltas that correspond to non c resources deltas.
*/
protected IResourceDelta[] resourceDeltas = null;
/**
* Counter of resource deltas
*/
protected int resourceDeltasCounter;
/**
* Empty array of ICElementDelta
*/
protected static ICElementDelta[] fgEmptyDelta= new ICElementDelta[] {};
/**
* @see #getAffectedChildren()
*/
protected ICElementDelta[] fAffectedChildren = fgEmptyDelta;
/**
* Creates the root delta. To create the nested delta
* hierarchies use the following convenience methods. The root
* delta can be created at any level (i.e. project, folder).
* <ul>
* <li><code>added(ICElement)</code>
* <li><code>changed(ICElement)</code>
* <li><code>moved(ICElement, ICElement)</code>
* <li><code>removed(ICElement)</code>
* <li><code>renamed(ICElement, ICElement)</code>
* </ul>
*/
public CElementDelta(ICElement element) {
super();
fChangedElement = element;
}
/**
* Adds the child delta to the collection of affected children. If the
* child is already in the collection, walk down the hierarchy.
*/
protected void addAffectedChild(CElementDelta child) {
switch (fKind) {
case ADDED:
case REMOVED:
// no need to add a child if this parent is added or removed
return;
case CHANGED:
fChangeFlags |= F_CHILDREN;
break;
default:
fKind = CHANGED;
fChangeFlags |= F_CHILDREN;
}
// if a child delta is added to a translation unit delta or below,
// it's a fine grained delta
if (!(fChangedElement.getElementType() >= ICElement.C_UNIT)) {
fineGrained();
}
if (fAffectedChildren.length == 0) {
fAffectedChildren = new ICElementDelta[] {child};
return;
}
// Check if we already have the delta.
ICElementDelta existingChild = null;
int existingChildIndex = -1;
for (int i = 0; i < fAffectedChildren.length; i++) {
// handle case of two jars that can be equals but not in the same project
if (equalsAndSameParent(fAffectedChildren[i].getElement(), child.getElement())) {
existingChild = fAffectedChildren[i];
existingChildIndex = i;
break;
}
}
if (existingChild == null) { //new affected child
fAffectedChildren= growAndAddToArray(fAffectedChildren, child);
} else {
switch (existingChild.getKind()) {
case ADDED:
switch (child.getKind()) {
// child was added then added -> it is added
case ADDED:
// child was added then changed -> it is added
case CHANGED:
return;
// child was added then removed -> noop
case REMOVED:
fAffectedChildren = removeAndShrinkArray(fAffectedChildren, existingChildIndex);
return;
}
break;
case REMOVED:
switch (child.getKind()) {
// child was removed then added -> it is changed
case ADDED:
child.fKind = CHANGED;
fAffectedChildren[existingChildIndex] = child;
return;
// child was removed then changed -> it is removed
case CHANGED:
// child was removed then removed -> it is removed
case REMOVED:
return;
}
break;
case CHANGED:
switch (child.getKind()) {
// child was changed then added -> it is added
case ADDED:
// child was changed then removed -> it is removed
case REMOVED:
fAffectedChildren[existingChildIndex] = child;
return;
// child was changed then changed -> it is changed
case CHANGED:
((CElementDelta) existingChild).fChangeFlags |= child.fChangeFlags;
ICElementDelta[] children = child.getAffectedChildren();
for (ICElementDelta element : children) {
CElementDelta childsChild = (CElementDelta) element;
((CElementDelta) existingChild).addAffectedChild(childsChild);
}
// add the non-c resource deltas if needed
// note that the child delta always takes
// precedence over this existing child delta
// as non-c resource deltas are always
// created last (by the DeltaProcessor)
IResourceDelta[] resDeltas = child.getResourceDeltas();
if (resDeltas != null) {
((CElementDelta)existingChild).resourceDeltas = resDeltas;
((CElementDelta)existingChild).resourceDeltasCounter = child.resourceDeltasCounter;
}
return;
}
break;
default:
// unknown -> existing child becomes the child with the existing child's flags
int flags = existingChild.getFlags();
fAffectedChildren[existingChildIndex] = child;
child.fChangeFlags |= flags;
}
}
}
/**
* Creates the nested deltas resulting from an add operation.
* Convenience method for creating add deltas.
* The constructor should be used to create the root delta
* and then an add operation should call this method.
*/
public void added(ICElement element) {
CElementDelta addedDelta = new CElementDelta(element);
addedDelta.fKind = ADDED;
insertDeltaTree(element, addedDelta);
}
/**
* Adds the child delta to the collection of affected children. If the
* child is already in the collection, walk down the hierarchy.
*/
protected void addResourceDelta(IResourceDelta child) {
switch (fKind) {
case ADDED:
case REMOVED:
// no need to add a child if this parent is added or removed
return;
case CHANGED:
fChangeFlags |= F_CONTENT;
break;
default:
fKind = CHANGED;
fChangeFlags |= F_CONTENT;
}
if (resourceDeltas == null) {
resourceDeltas = new IResourceDelta[5];
resourceDeltas[resourceDeltasCounter++] = child;
return;
}
if (resourceDeltas.length == resourceDeltasCounter) {
// need a resize
System.arraycopy(resourceDeltas, 0, (resourceDeltas = new IResourceDelta[resourceDeltasCounter * 2]), 0, resourceDeltasCounter);
}
resourceDeltas[resourceDeltasCounter++] = child;
}
/**
* Creates the nested deltas resulting from a change operation.
* Convenience method for creating change deltas.
* The constructor should be used to create the root delta
* and then a change operation should call this method.
*/
public void changed(ICElement element, int changeFlag) {
CElementDelta changedDelta = new CElementDelta(element);
changedDelta.fKind = CHANGED;
changedDelta.fChangeFlags |= changeFlag;
insertDeltaTree(element, changedDelta);
}
/**
* Creates the nested deltas for a closed element.
*/
public void closed(ICElement element) {
CElementDelta delta = new CElementDelta(element);
delta.fKind = CHANGED;
delta.fChangeFlags |= F_CLOSED;
insertDeltaTree(element, delta);
}
/**
* Returns whether the two c elements are equals and have the same parent.
*/
protected boolean equalsAndSameParent(ICElement e1, ICElement e2) {
ICElement parent1;
return e1.equals(e2) && ((parent1 = e1.getParent()) != null) && parent1.equals(e2.getParent());
}
/**
* Creates the nested delta deltas based on the affected element
* its delta, and the root of this delta tree. Returns the root
* of the created delta tree.
*/
protected CElementDelta createDeltaTree(ICElement element, CElementDelta delta) {
CElementDelta childDelta = delta;
ArrayList<ICElement> ancestors= getAncestors(element);
if (ancestors == null) {
if (equalsAndSameParent(delta.getElement(), getElement())) {
// handle case of two jars that can be equals but not in the
// same project
// the element being changed is the root element
fKind= delta.fKind;
fChangeFlags = delta.fChangeFlags;
fMovedToHandle = delta.fMovedToHandle;
fMovedFromHandle = delta.fMovedFromHandle;
} else {
// the given delta is not the root or a child - illegal
//Assert.isTrue(false);
}
} else {
for (int i = 0, size = ancestors.size(); i < size; i++) {
ICElement ancestor = ancestors.get(i);
CElementDelta ancestorDelta = new CElementDelta(ancestor);
ancestorDelta.addAffectedChild(childDelta);
childDelta = ancestorDelta;
}
}
return childDelta;
}
/**
* Returns the <code>CElementDelta</code> for the given element
* in the delta tree, or null, if no delta for the given element is found.
*/
protected CElementDelta find(ICElement e) {
if (equalsAndSameParent(fChangedElement, e)) { // handle case of two jars that can be equals but not in the same project
return this;
}
for (ICElementDelta element : fAffectedChildren) {
CElementDelta delta = ((CElementDelta)element).find(e);
if (delta != null) {
return delta;
}
}
return null;
}
/**
* Mark this delta as a fine-grained delta.
*/
public void fineGrained() {
fChangeFlags |= F_FINE_GRAINED;
}
/**
* @see ICElementDelta
*/
@Override
public ICElementDelta[] getAddedChildren() {
return getChildrenOfType(ADDED);
}
/**
* @see ICElementDelta
*/
@Override
public ICElementDelta[] getAffectedChildren() {
return fAffectedChildren;
}
/**
* Returns a collection of all the parents of this element up to (but
* not including) the root of this tree in bottom-up order. If the given
* element is not a descendant of the root of this tree, <code>null</code>
* is returned.
*/
private ArrayList<ICElement> getAncestors(ICElement element) {
ICElement parent = element.getParent();
if (parent == null) {
return null;
}
ArrayList<ICElement> parents = new ArrayList<ICElement>();
while (!parent.equals(fChangedElement)) {
parents.add(parent);
parent = parent.getParent();
if (parent == null) {
return null;
}
}
parents.trimToSize();
return parents;
}
/**
* @see ICElementDelta
*/
@Override
public ICElementDelta[] getChangedChildren() {
return getChildrenOfType(CHANGED);
}
/**
* @see ICElementDelta
*/
protected ICElementDelta[] getChildrenOfType(int type) {
int length = fAffectedChildren.length;
if (length == 0) {
return new ICElementDelta[] {};
}
ArrayList<ICElementDelta> children= new ArrayList<ICElementDelta>(length);
for (int i = 0; i < length; i++) {
if (fAffectedChildren[i].getKind() == type) {
children.add(fAffectedChildren[i]);
}
}
ICElementDelta[] childrenOfType = new ICElementDelta[children.size()];
children.toArray(childrenOfType);
return childrenOfType;
}
/**
* Returns the delta for a given element. Only looks below this
* delta.
*/
protected CElementDelta getDeltaFor(ICElement element) {
if (equalsAndSameParent(getElement(), element)) // handle case of two jars that can be equals but not in the same project
return this;
if (fAffectedChildren.length == 0)
return null;
int childrenCount = fAffectedChildren.length;
for (int i = 0; i < childrenCount; i++) {
CElementDelta delta = (CElementDelta)fAffectedChildren[i];
if (equalsAndSameParent(delta.getElement(), element)) { // handle case of two jars that can be equals but not in the same project
return delta;
}
delta = delta.getDeltaFor(element);
if (delta != null)
return delta;
}
return null;
}
/**
* @see ICElementDelta
*/
@Override
public ICElement getElement() {
return fChangedElement;
}
/**
* @see ICElementDelta
*/
@Override
public int getFlags() {
return fChangeFlags;
}
/**
* @see ICElementDelta
*/
@Override
public int getKind() {
return fKind;
}
/**
* @see ICElementDelta
*/
@Override
public ICElement getMovedFromElement() {
return fMovedFromHandle;
}
/**
* @see ICElementDelta
*/
@Override
public ICElement getMovedToElement() {
return fMovedToHandle;
}
/**
* @see ICElementDelta
*/
@Override
public ICElementDelta[] getRemovedChildren() {
return getChildrenOfType(REMOVED);
}
/**
* Return the collection of resource deltas. Return null if none.
*/
@Override
public IResourceDelta[] getResourceDeltas() {
if (resourceDeltas == null)
return null;
if (resourceDeltas.length != resourceDeltasCounter) {
System.arraycopy(resourceDeltas, 0, resourceDeltas = new IResourceDelta[resourceDeltasCounter], 0, resourceDeltasCounter);
}
return resourceDeltas;
}
/**
* Adds the new element to a new array that contains all of the elements of the old array.
* Returns the new array.
*/
protected ICElementDelta[] growAndAddToArray(ICElementDelta[] array, ICElementDelta addition) {
ICElementDelta[] old = array;
array = new ICElementDelta[old.length + 1];
System.arraycopy(old, 0, array, 0, old.length);
array[old.length] = addition;
return array;
}
/**
* Creates the delta tree for the given element and delta, and then
* inserts the tree as an affected child of this node.
*/
protected void insertDeltaTree(ICElement element, CElementDelta delta) {
CElementDelta childDelta= createDeltaTree(element, delta);
if (!equalsAndSameParent(element, getElement())) {
addAffectedChild(childDelta);
}
}
/**
* Creates the nested deltas resulting from an move operation.
* Convenience method for creating the "move from" delta.
* The constructor should be used to create the root delta
* and then the move operation should call this method.
*/
public void movedFrom(ICElement movedFromElement, ICElement movedToElement) {
CElementDelta removedDelta = new CElementDelta(movedFromElement);
removedDelta.fKind = REMOVED;
removedDelta.fChangeFlags |= F_MOVED_TO;
removedDelta.fMovedToHandle = movedToElement;
insertDeltaTree(movedFromElement, removedDelta);
}
/**
* Creates the nested deltas resulting from an move operation.
* Convenience method for creating the "move to" delta.
* The constructor should be used to create the root delta
* and then the move operation should call this method.
*/
public void movedTo(ICElement movedToElement, ICElement movedFromElement) {
CElementDelta addedDelta = new CElementDelta(movedToElement);
addedDelta.fKind = ADDED;
addedDelta.fChangeFlags |= F_MOVED_FROM;
addedDelta.fMovedFromHandle = movedFromElement;
insertDeltaTree(movedToElement, addedDelta);
}
/**
* Creates the nested deltas for an opened element.
*/
public void opened(ICElement element) {
CElementDelta delta = new CElementDelta(element);
delta.fKind = CHANGED;
delta.fChangeFlags |= F_OPENED;
insertDeltaTree(element, delta);
}
/**
* Removes the child delta from the collection of affected children.
*/
protected void removeAffectedChild(CElementDelta child) {
int index = -1;
if (fAffectedChildren != null) {
for (int i = 0; i < fAffectedChildren.length; i++) {
if (equalsAndSameParent(fAffectedChildren[i].getElement(), child.getElement())) { // handle case of two jars that can be equals but not in the same project
index = i;
break;
}
}
}
if (index >= 0) {
fAffectedChildren= removeAndShrinkArray(fAffectedChildren, index);
}
}
/**
* Removes the element from the array.
* Returns the a new array which has shrunk.
*/
protected ICElementDelta[] removeAndShrinkArray(ICElementDelta[] old, int index) {
ICElementDelta[] array = new ICElementDelta[old.length - 1];
if (index > 0)
System.arraycopy(old, 0, array, 0, index);
int rest = old.length - index - 1;
if (rest > 0)
System.arraycopy(old, index + 1, array, index, rest);
return array;
}
/**
* Creates the nested deltas resulting from an delete operation.
* Convenience method for creating removed deltas.
* The constructor should be used to create the root delta
* and then the delete operation should call this method.
*/
public void removed(ICElement element) {
CElementDelta removedDelta= new CElementDelta(element);
insertDeltaTree(element, removedDelta);
CElementDelta actualDelta = getDeltaFor(element);
if (actualDelta != null) {
actualDelta.fKind = REMOVED;
actualDelta.fChangeFlags = 0;
actualDelta.fAffectedChildren = fgEmptyDelta;
}
}
/**
* Creates the nested deltas resulting from a change operation.
* Convenience method for creating change deltas.
* The constructor should be used to create the root delta
* and then a change operation should call this method.
*/
public void binaryParserChanged(ICElement element) {
CElementDelta attachedDelta = new CElementDelta(element);
attachedDelta.fKind = CHANGED;
attachedDelta.fChangeFlags |= F_BINARY_PARSER_CHANGED;
insertDeltaTree(element, attachedDelta);
}
/**
* Creates the nested deltas resulting from a change operation.
* Convenience method for creating change deltas.
* The constructor should be used to create the root delta
* and then a change operation should call this method.
*/
public void sourceAttached(ICElement element) {
CElementDelta attachedDelta = new CElementDelta(element);
attachedDelta.fKind = CHANGED;
attachedDelta.fChangeFlags |= F_SOURCEATTACHED;
insertDeltaTree(element, attachedDelta);
}
/**
* Creates the nested deltas resulting from a change operation.
* Convenience method for creating change deltas.
* The constructor should be used to create the root delta
* and then a change operation should call this method.
*/
public void sourceDetached(ICElement element) {
CElementDelta detachedDelta = new CElementDelta(element);
detachedDelta.fKind = CHANGED;
detachedDelta.fChangeFlags |= F_SOURCEDETACHED;
insertDeltaTree(element, detachedDelta);
}
/**
* Returns a string representation of this delta's
* structure suitable for debug purposes.
*
* @see #toString()
*/
public String toDebugString(int depth) {
StringBuilder buffer = new StringBuilder();
for (int i= 0; i < depth; i++) {
buffer.append('\t');
}
buffer.append(((CElement)getElement()).toDebugString());
buffer.append(" ["); //$NON-NLS-1$
switch (getKind()) {
case ICElementDelta.ADDED :
buffer.append('+');
break;
case ICElementDelta.REMOVED :
buffer.append('-');
break;
case ICElementDelta.CHANGED :
buffer.append('*');
break;
default :
buffer.append('?');
break;
}
buffer.append("]: {"); //$NON-NLS-1$
int changeFlags = getFlags();
boolean prev = false;
if ((changeFlags & ICElementDelta.F_CHILDREN) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("CHILDREN"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_CONTENT) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("CONTENT"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_MOVED_FROM) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
//buffer.append("MOVED_FROM(").append(((CElement)getMovedFromElement()).toStringWithAncestors().append(')'); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_MOVED_TO) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
//buffer.append("MOVED_TO(").append(((CElement)getMovedToElement()).toStringWithAncestors()).append(')'); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_MODIFIERS) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("MODIFIERS CHANGED"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_CHANGED_PATHENTRY_INCLUDE) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("CHANGED TO PATHENTRY INCLUDE"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_CHANGED_PATHENTRY_MACRO) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("CHANGED TO PATHENTRY MACRO"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_ADDED_PATHENTRY_LIBRARY) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("ADDED TO PATHENTRY LIBRARY"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_REMOVED_PATHENTRY_LIBRARY) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("ADDED TO PATHENTRY LIBRARY"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_PATHENTRY_REORDER) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("PATHENTRY REORDER"); //$NON-NLS-1$
prev = true;
}
if ((changeFlags & ICElementDelta.F_CONTENT_TYPE) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("CONTENT_TYPE"); //$NON-NLS-1$
prev = true;
}
//if ((changeFlags & ICElementDelta.F_SUPER_TYPES) != 0) {
// if (prev)
// buffer.append(" | "); //$NON-NLS-1$
// buffer.append("SUPER TYPES CHANGED"); //$NON-NLS-1$
// prev = true;
//}
if ((changeFlags & ICElementDelta.F_FINE_GRAINED) != 0) {
if (prev)
buffer.append(" | "); //$NON-NLS-1$
buffer.append("FINE GRAINED"); //$NON-NLS-1$
prev = true;
}
buffer.append("}"); //$NON-NLS-1$
ICElementDelta[] children = getAffectedChildren();
if (children != null) {
for (int i = 0; i < children.length; ++i) {
buffer.append("\n"); //$NON-NLS-1$
buffer.append(((CElementDelta) children[i]).toDebugString(depth + 1));
}
}
for (int i = 0; i < resourceDeltasCounter; i++) {
buffer.append("\n");//$NON-NLS-1$
for (int j = 0; j < depth+1; j++) {
buffer.append('\t');
}
IResourceDelta resourceDelta = resourceDeltas[i];
buffer.append(resourceDelta.toString());
buffer.append("["); //$NON-NLS-1$
switch (resourceDelta.getKind()) {
case IResourceDelta.ADDED :
buffer.append('+');
break;
case IResourceDelta.REMOVED :
buffer.append('-');
break;
case IResourceDelta.CHANGED :
buffer.append('*');
break;
default :
buffer.append('?');
break;
}
buffer.append("]"); //$NON-NLS-1$
}
return buffer.toString();
}
/**
* Returns a string representation of this delta's
* structure suitable for debug purposes.
*/
@Override
public String toString() {
return toDebugString(0);
}
}