Java IJavaElementDelta.REMOVED属性代码示例

/**
 * Collects all the deltas of the changes.
 * @param delta the root delta of the change
 * @param deltas the collection of the deltas to be collected
 */
private void collectDeltas(IJavaElementDelta delta) {
    if (delta.getKind() == IJavaElementDelta.ADDED ||
        delta.getKind() == IJavaElementDelta.REMOVED) {
        if (!contain(delta)) {
            deltas.add(delta);
        }
    } else if (delta.getKind() == IJavaElementDelta.CHANGED &&
            ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0)) {
        if (!contain(delta)) {
            deltas.add(delta);
        }
    }
    
    for (IJavaElementDelta d : delta.getAffectedChildren()) {
        collectDeltas(d);
    }
}
 

private Set<IJavaProject> getJavaProjectsWithClasspathChange(IJavaElementDelta delta) {
	IJavaElement element = delta.getElement();
	if (element instanceof IPackageFragmentRoot) {
		IPackageFragmentRoot root = (IPackageFragmentRoot) element;
		if (delta.getKind() == IJavaElementDelta.REMOVED || delta.getKind() == IJavaElementDelta.ADDED
				|| (delta.getFlags() & IJavaElementDelta.F_REORDER) != 0
				|| (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
				|| (delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
				|| (root.isExternal() && (delta.getFlags() & // external folders change
				(IJavaElementDelta.F_CONTENT | IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED)) == delta
						.getFlags())) {
			return Collections.singleton(root.getJavaProject());
		}
	} else if (element instanceof IJavaModel) {
		return getPackageFragmentRootDeltas(delta.getAffectedChildren());
	} else if (element instanceof IJavaProject) {
		if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0
				|| (delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0)
			return Collections.singleton((IJavaProject) element);
		return getPackageFragmentRootDeltas(delta.getAffectedChildren());
	}
	return Collections.emptySet();
}
 

private boolean isAffectingPackageFragmentRoots(IJavaElementDelta delta) {
	IJavaElement element = delta.getElement();
	if (element instanceof IPackageFragmentRoot) {
		if (delta.getKind() == IJavaElementDelta.REMOVED
			|| delta.getKind() == IJavaElementDelta.ADDED
			|| (delta.getFlags() & IJavaElementDelta.F_REORDER) != 0
			|| (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
			|| (delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
			|| (((IPackageFragmentRoot) element).isExternal() && (delta.getFlags() & // external folders change
					(IJavaElementDelta.F_CONTENT 
							| IJavaElementDelta.F_SOURCEATTACHED 
							| IJavaElementDelta.F_SOURCEDETACHED)) == delta.getFlags())) {
			return true;
		}
	} else if (element instanceof IJavaModel) {
		return isAffectingPackageFragmentRoots(delta.getAffectedChildren());
	} else if (element instanceof IJavaProject) {
		if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0 ||
				(delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0)
			return true;
		return isAffectingPackageFragmentRoots(delta.getAffectedChildren());
	}
	return false;
}
 

private void collectRemoved(
    Set<IAdaptable> potentiallyRemovedSet,
    Set<IAdaptable> removedElements,
    IJavaElementDelta delta) {
  if (delta.getKind() == IJavaElementDelta.REMOVED) removedElements.add(delta.getElement());
  else if (delta.getKind() == IJavaElementDelta.CHANGED) {
    int flags = delta.getFlags();
    if ((flags & REMOVED_FLAGS) != 0) {
      potentiallyRemovedSet.add(delta.getElement());
    } else {
      IJavaElementDelta[] childDeltas = delta.getAffectedChildren();
      for (int i = 0; i < childDeltas.length; i++) {
        collectRemoved(potentiallyRemovedSet, removedElements, childDeltas[i]);
      }
    }
  }
  IResourceDelta[] resourceDeltas = delta.getResourceDeltas();
  if (resourceDeltas != null) {
    for (int i = 0; i < resourceDeltas.length; i++) {
      collectRemovals(removedElements, resourceDeltas[i]);
    }
  }
}
 

private void collectRemoved(Set<IAdaptable> potentiallyRemovedSet, Set<IAdaptable> removedElements, IJavaElementDelta delta) {
	if (delta.getKind() == IJavaElementDelta.REMOVED)
		removedElements.add(delta.getElement());
	else if (delta.getKind() == IJavaElementDelta.CHANGED) {
		int flags= delta.getFlags();
		if ((flags & REMOVED_FLAGS) != 0) {
			potentiallyRemovedSet.add(delta.getElement());
		} else {
			IJavaElementDelta[] childDeltas= delta.getAffectedChildren();
			for (int i= 0; i < childDeltas.length; i++) {
				collectRemoved(potentiallyRemovedSet, removedElements, childDeltas[i]);
			}
		}
	}
	IResourceDelta[] resourceDeltas= delta.getResourceDeltas();
	if (resourceDeltas != null) {
		for (int i= 0; i < resourceDeltas.length; i++) {
			collectRemovals(removedElements, resourceDeltas[i]);
		}
	}
}
 

private void addChange(IMember member, IJavaElementDelta newDelta) throws JavaModelException {
	int newKind = newDelta.getKind();
	switch (newKind) {
		case IJavaElementDelta.ADDED:
			ArrayList allTypes = new ArrayList();
			getAllTypesFromElement(member, allTypes);
			for (int i = 0, length = allTypes.size(); i < length; i++) {
				IType innerType = (IType)allTypes.get(i);
				addTypeAddition(innerType, (SimpleDelta)this.changes.get(innerType));
			}
			break;
		case IJavaElementDelta.REMOVED:
			allTypes = new ArrayList();
			getAllTypesFromHierarchy((JavaElement)member, allTypes);
			for (int i = 0, length = allTypes.size(); i < length; i++) {
				IType type = (IType)allTypes.get(i);
				addTypeRemoval(type, (SimpleDelta)this.changes.get(type));
			}
			break;
		case IJavaElementDelta.CHANGED:
			addAffectedChildren(newDelta);
			break;
	}
}
 

protected void toDebugString(StringBuffer buffer) {
	buffer.append("["); //$NON-NLS-1$
	switch (getKind()) {
		case IJavaElementDelta.ADDED :
			buffer.append('+');
			break;
		case IJavaElementDelta.REMOVED :
			buffer.append('-');
			break;
		case IJavaElementDelta.CHANGED :
			buffer.append('*');
			break;
		default :
			buffer.append('?');
			break;
	}
	buffer.append("]: {"); //$NON-NLS-1$
	toDebugString(buffer, getFlags());
	buffer.append("}"); //$NON-NLS-1$
}
 

public void processDelta(IJavaElementDelta delta, int eventType) {
  switch (delta.getKind()) {
    case IJavaElementDelta.CHANGED:
      IJavaElementDelta[] children = delta.getAffectedChildren();
      for (int i = 0, length = children.length; i < length; i++) {
        IJavaElementDelta child = children[i];
        processDelta(child, eventType);
      }
      break;
    case IJavaElementDelta.REMOVED:
      IJavaElement element = delta.getElement();
      if (this.encloses(element)) {
        if (this.elements != null) {
          this.elements.remove(element);
        }
        String path = null;
        switch (element.getElementType()) {
          case IJavaElement.JAVA_PROJECT:
            path = ((IJavaProject) element).getProject().getFullPath().toString();
            break;
          case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            path = ((IPackageFragmentRoot) element).getPath().toString();
            break;
          default:
            return;
        }
        for (int i = 0; i < this.pathsCount; i++) {
          if (this.relativePaths[i].equals(path)) {
            this.relativePaths[i] = null;
            rehash();
            break;
          }
        }
      }
      break;
  }
}
 

@Override
protected void processDelta(IJavaElementDelta delta, List<IJavaElement> result) {
	IJavaElement elem= delta.getElement();

	boolean isChanged= delta.getKind() == IJavaElementDelta.CHANGED;
	boolean isRemoved= delta.getKind() == IJavaElementDelta.REMOVED;
	int flags= delta.getFlags();

	switch (elem.getElementType()) {
		case IJavaElement.JAVA_MODEL:
			processChildrenDelta(delta, result);
			return;
		case IJavaElement.JAVA_PROJECT:
			if (isRemoved || (isChanged &&
					(flags & IJavaElementDelta.F_CLOSED) != 0)) {
				return;
			}
			processChildrenDelta(delta, result);
			return;
		case IJavaElement.PACKAGE_FRAGMENT_ROOT:
			if (isRemoved) {
				return;
			}
			try {
				if ((((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) ||
						((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0))
						&& ((IPackageFragmentRoot)elem).getKind() != IPackageFragmentRoot.K_SOURCE) {
					result.add(elem);
				}
			} catch (JavaModelException e) {
				// don't update
			}
			return;
		default:
			return;
	}
}
 

private void processJavaDelta(WorkingSetDelta result, IJavaElementDelta delta) {
	IJavaElement jElement= delta.getElement();
	int index= result.indexOf(jElement);
	int type= jElement.getElementType();
	int kind= delta.getKind();
	int flags= delta.getFlags();
	if (type == IJavaElement.JAVA_PROJECT && kind == IJavaElementDelta.CHANGED) {
		if (index != -1 && (flags & IJavaElementDelta.F_CLOSED) != 0) {
			result.set(index, ((IJavaProject)jElement).getProject());
		} else if ((flags & IJavaElementDelta.F_OPENED) != 0) {
			index= result.indexOf(((IJavaProject)jElement).getProject());
			if (index != -1)
				result.set(index, jElement);
		}
	}
	if (index != -1) {
		if (kind == IJavaElementDelta.REMOVED) {
			if ((flags & IJavaElementDelta.F_MOVED_TO) != 0) {
				result.set(index, delta.getMovedToElement());
			} else {
				result.remove(index);
			}
		}
	}
	IResourceDelta[] resourceDeltas= delta.getResourceDeltas();
	if (resourceDeltas != null) {
		for (int i= 0; i < resourceDeltas.length; i++) {
			processResourceDelta(result, resourceDeltas[i]);
		}
	}
	IJavaElementDelta[] children= delta.getAffectedChildren();
	for (int i= 0; i < children.length; i++) {
		processJavaDelta(result, children[i]);
	}
}
 

public void processDelta(IJavaElementDelta delta, int eventType) {
	switch (delta.getKind()) {
		case IJavaElementDelta.CHANGED:
			IJavaElementDelta[] children = delta.getAffectedChildren();
			for (int i = 0, length = children.length; i < length; i++) {
				IJavaElementDelta child = children[i];
				processDelta(child, eventType);
			}
			break;
		case IJavaElementDelta.REMOVED:
			IJavaElement element = delta.getElement();
			if (this.encloses(element)) {
				if (this.elements != null) {
					this.elements.remove(element);
				}
				String path = null;
				switch (element.getElementType()) {
					case IJavaElement.JAVA_PROJECT:
						path = ((IJavaProject)element).getProject().getFullPath().toString();
						break;
					case IJavaElement.PACKAGE_FRAGMENT_ROOT:
						path = ((IPackageFragmentRoot)element).getPath().toString();
						break;
					default:
						return;
				}
				for (int i = 0; i < this.pathsCount; i++) {
					if (this.relativePaths[i].equals(path)) {
						this.relativePaths[i] = null;
						rehash();
						break;
					}
				}
			}
			break;
	}
}
 

private void addChange(IImportContainer importContainer, IJavaElementDelta newDelta) throws JavaModelException {
	int newKind = newDelta.getKind();
	if (newKind == IJavaElementDelta.CHANGED) {
		addAffectedChildren(newDelta);
		return;
	}
	SimpleDelta existingDelta = (SimpleDelta)this.changes.get(importContainer);
	if (existingDelta != null) {
		switch (newKind) {
			case IJavaElementDelta.ADDED:
				if (existingDelta.getKind() == IJavaElementDelta.REMOVED) {
					// REMOVED then ADDED
					this.changes.remove(importContainer);
				}
				break;
			case IJavaElementDelta.REMOVED:
				if (existingDelta.getKind() == IJavaElementDelta.ADDED) {
					// ADDED then REMOVED
					this.changes.remove(importContainer);
				}
				break;
				// CHANGED handled above
		}
	} else {
		SimpleDelta delta = new SimpleDelta();
		switch (newKind) {
			case IJavaElementDelta.ADDED:
				delta.added();
				break;
			case IJavaElementDelta.REMOVED:
				delta.removed();
				break;
		}
		this.changes.put(importContainer, delta);
	}
}
 

private void addTypeAddition(IType type, SimpleDelta existingDelta) throws JavaModelException {
	if (existingDelta != null) {
		switch (existingDelta.getKind()) {
			case IJavaElementDelta.REMOVED:
				// REMOVED then ADDED
				boolean hasChange = false;
				if (hasSuperTypeChange(type)) {
					existingDelta.superTypes();
					hasChange = true;
				}
				if (hasVisibilityChange(type)) {
					existingDelta.modifiers();
					hasChange = true;
				}
				if (!hasChange) {
					this.changes.remove(type);
				}
				break;
				// CHANGED then ADDED
				// or ADDED then ADDED: should not happen
		}
	} else {
		// check whether the type addition affects the hierarchy
		String typeName = type.getElementName();
		if (this.hierarchy.hasSupertype(typeName)
				|| this.hierarchy.subtypesIncludeSupertypeOf(type)
				|| this.hierarchy.missingTypes.contains(typeName)) {
			SimpleDelta delta = new SimpleDelta();
			delta.added();
			this.changes.put(type, delta);
		}
	}
}
 

private String deltaKindToString(int kind) {
	if (kind == IJavaElementDelta.ADDED)
		return "ADDED";
	else if (kind == IJavaElementDelta.CHANGED)
		return "CHANGED";
	else if (kind == IJavaElementDelta.REMOVED)
		return "REMOVED";
	throw new IllegalArgumentException("Unknown delta kind");
}
 

private boolean isClasspathChanged(IJavaElementDelta delta) {
	return delta.getKind() == IJavaElementDelta.REMOVED ||
			(0 != (delta.getFlags() & (IJavaElementDelta.F_CLASSPATH_CHANGED | IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED)));
}