Java IJavaElementDelta类代码示例

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
/**
 * Creates a macro corresponding to the removed delta of the change.
 * @param time the time when the change occurred
 * @param delta the removed delta of the change
 * @return the created resource macro
 */
private ResourceMacro createResourceRemovedMacro(long time, IJavaElementDelta delta) {
    IJavaElement elem = delta.getElement();
    String path = elem.getPath().toString();
    if (path == null) {
        return null;
    }
    
    String type = "Removed";
    if ((delta.getFlags() & IJavaElementDelta.F_MOVED_TO) != 0) {
        if (isRenamed(delta.getElement(), delta.getMovedToElement())) {
            type = "RenamedTo";
        } else {
            type = "MovedTo";
        }
    }
    
    return new ResourceMacro(time, type, path, elem);
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
/**
 * Creates a macro corresponding to the added delta of the change.
 * @param time the time when the change occurred
 * @param delta the added delta of the change
 * @return the created resource macro
 */
private ResourceMacro createResourceAddedMacro(long time, IJavaElementDelta delta) {
    IJavaElement elem = delta.getElement();
    String path = elem.getPath().toString();
    if (path == null) {
        return null;
    }
    
    String type = "Added";
    if ((delta.getFlags() & IJavaElementDelta.F_MOVED_FROM) != 0) {
        if (isRenamed(delta.getElement(), delta.getMovedFromElement())) {
            type = "RenamedFrom";
        } else {
            type = "MovedFrom";
        }
    }
    
    return new ResourceMacro(time, type, path, elem);
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private void visit(IJavaElementDelta delta) {
	IJavaElement el = delta.getElement();
	switch (el.getElementType()) {
	case IJavaElement.JAVA_MODEL:
		for (IJavaElementDelta c : delta.getAffectedChildren()) {
			visit(c);
		}
		break;
	case IJavaElement.JAVA_PROJECT:
		IJavaProject javaProject = (IJavaProject) el;
		if (isClasspathChanged(delta)) {
			detectionJob.analyze(javaProject);
		}
		break;
	default:
		break;
	}
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private Set<IJavaElementDelta> getProjectDeltas(IJavaElementDelta delta) {
	IJavaElement element = delta.getElement();
	if(delta.getElement().getElementType() == IJavaElement.JAVA_PROJECT) {
		return Collections.singleton(delta);
	}
	Set<IJavaElementDelta> result = null;
	if(element instanceof IJavaModel) {
		if(delta.getAddedChildren()!=null) {
			for(IJavaElementDelta child: delta.getAffectedChildren()) {
				Set<IJavaElementDelta> projectDeltas = getProjectDeltas(child);
				if(!projectDeltas.isEmpty()) {
					if(result == null)
						result = newLinkedHashSet(); 
					result.addAll(projectDeltas);
				}
			}
		}
	}
	return result == null ? Collections.<IJavaElementDelta>emptySet() : result;
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
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();
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
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;
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
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]);
    }
  }
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
protected void addReconcileDelta(ICompilationUnit workingCopy, IJavaElementDelta delta) {
  HashMap reconcileDeltas =
      JavaModelManager.getJavaModelManager().getDeltaProcessor().reconcileDeltas;
  org.eclipse.jdt.internal.core.JavaElementDelta previousDelta =
      (org.eclipse.jdt.internal.core.JavaElementDelta) reconcileDeltas.get(workingCopy);
  if (previousDelta != null) {
    IJavaElementDelta[] children = delta.getAffectedChildren();
    for (int i = 0, length = children.length; i < length; i++) {
      org.eclipse.jdt.internal.core.JavaElementDelta child =
          (org.eclipse.jdt.internal.core.JavaElementDelta) children[i];
      previousDelta.insertDeltaTree(child.getElement(), child);
    }
    // note that the last delta's AST always takes precedence over the existing delta's AST
    // since it is the result of the last reconcile operation
    if ((delta.getFlags() & IJavaElementDelta.F_AST_AFFECTED) != 0) {
      previousDelta.changedAST(delta.getCompilationUnitAST());
    }

  } else {
    reconcileDeltas.put(workingCopy, delta);
  }
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private void firePostChangeDelta(
    IJavaElementDelta deltaToNotify,
    IElementChangedListener[] listeners,
    int[] listenerMask,
    int listenerCount) {

  // post change deltas
  if (DEBUG) {
    System.out.println(
        "FIRING POST_CHANGE Delta [" + Thread.currentThread() + "]:"); // $NON-NLS-1$//$NON-NLS-2$
    System.out.println(
        deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); // $NON-NLS-1$
  }
  if (deltaToNotify != null) {
    // flush now so as to keep listener reactions to post their own deltas for subsequent
    // iteration
    flush();

    //			// mark the operation stack has not modifying resources since resource deltas are being
    // fired
    //			JavaModelOperation.setAttribute(JavaModelOperation.HAS_MODIFIED_RESOURCE_ATTR, null);

    notifyListeners(
        deltaToNotify, ElementChangedEvent.POST_CHANGE, listeners, listenerMask, listenerCount);
  }
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private void fireReconcileDelta(
    IElementChangedListener[] listeners, int[] listenerMask, int listenerCount) {

  IJavaElementDelta deltaToNotify = mergeDeltas(this.reconcileDeltas.values());
  if (DEBUG) {
    System.out.println(
        "FIRING POST_RECONCILE Delta ["
            + Thread.currentThread()
            + "]:"); // $NON-NLS-1$//$NON-NLS-2$
    System.out.println(
        deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); // $NON-NLS-1$
  }
  if (deltaToNotify != null) {
    // flush now so as to keep listener reactions to post their own deltas for subsequent
    // iteration
    this.reconcileDeltas = new HashMap();

    notifyListeners(
        deltaToNotify,
        ElementChangedEvent.POST_RECONCILE,
        listeners,
        listenerMask,
        listenerCount);
  }
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private boolean ignoreClasspathChanges(ElementChangedEvent event) {
	if (event.getDelta() == null && event.getDelta().getChangedChildren() == null)
		return true;
	for (IJavaElementDelta delta : event.getDelta().getChangedChildren()) {
		if (delta.getResourceDeltas() == null)
			return false;
		for (IResourceDelta rd : delta.getResourceDeltas()) {
			if (rd.getFullPath() == null)
				continue;
			String path = rd.getFullPath().getFileExtension();
			if (path != null && !(path.equalsIgnoreCase(FileExtension.JRXML) || path.equalsIgnoreCase(FileExtension.JASPER)))
				return false;
		}
	}
	return true;
}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
@Override
public void reconcile(final ReconcileContext context) {
	if (FileCompletionPreferencePage.checkDuringTyping) {
		if (context == null) {
			LOG.fine("context is null");
		} else {
			IJavaElementDelta delta = context.getDelta();
			if (delta == null) {
				LOG.fine("delta is null");
			} else {
				reconcileImpl(context, delta);
			}
		}
	}

}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
private IJavaElementDelta findElement(IJavaElement target, IJavaElementDelta delta) {

			if (delta == null || target == null)
				return null;

			IJavaElement element= delta.getElement();

			if (element.getElementType() > IJavaElement.CLASS_FILE)
				return null;

			if (target.equals(element))
				return delta;

			IJavaElementDelta[] children= delta.getAffectedChildren();

			for (int i= 0; i < children.length; i++) {
				IJavaElementDelta d= findElement(target, children[i]);
				if (d != null)
					return d;
			}

			return null;
		}
 

import org.eclipse.jdt.core.IJavaElementDelta; //导入依赖的package包/类
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]);
		}
	}
}