org.eclipse.jdt.core.dom.ASTRequestor#org.eclipse.core.runtime.SubProgressMonitor源码实例Demo

private List<NonNLSElement> analyze(IJavaProject project, IProgressMonitor pm) throws CoreException {
	try{
		IPackageFragment[] packs= project.getPackageFragments();
		pm.beginTask("", packs.length); //$NON-NLS-1$
		List<NonNLSElement> result= new ArrayList<NonNLSElement>();
		for (int i= 0; i < packs.length; i++) {
			if (! packs[i].isReadOnly())
				result.addAll(analyze(packs[i], new SubProgressMonitor(pm, 1)));
			else
				pm.worked(1);
		}
		return result;
	} finally{
		pm.done();
	}
}
 

public void readRows(IProgressMonitor monitor) throws ParserConfigurationException, SAXException, IOException, OpenXML4JException {
	monitor.beginTask("", 10);
	monitor.worked(1);
	OPCPackage p = OPCPackage.open(xlsxFile, PackageAccess.READ);
	ReadOnlySharedStringsTable shareString = new ReadOnlySharedStringsTable(p);
	XSSFReader xssfReader = new XSSFReader(p);
	XSSFReader.SheetIterator iter = (XSSFReader.SheetIterator) xssfReader.getSheetsData();
	try {
		while (iter.hasNext()) {
			InputStream stream = iter.next();
			readCells(stream, shareString, new SubProgressMonitor(monitor, 9));
			stream.close();
			// 目前只处理第一个sheet
			break;
		}
	} finally {
		p.close();
		monitor.done();
	}
}
 

private void addImportsToTargetUnit(final ICompilationUnit targetUnit, final IProgressMonitor monitor) throws CoreException, JavaModelException {
	monitor.beginTask("", 2); //$NON-NLS-1$
	try {
		ImportRewrite rewrite= StubUtility.createImportRewrite(targetUnit, true);
		if (fTypeImports != null) {
			ITypeBinding type= null;
			for (final Iterator<ITypeBinding> iterator= fTypeImports.iterator(); iterator.hasNext();) {
				type= iterator.next();
				rewrite.addImport(type);
			}
		}
		if (fStaticImports != null) {
			IBinding binding= null;
			for (final Iterator<IBinding> iterator= fStaticImports.iterator(); iterator.hasNext();) {
				binding= iterator.next();
				rewrite.addStaticImport(binding);
			}
		}
		fTypeImports= null;
		fStaticImports= null;
		TextEdit edits= rewrite.rewriteImports(new SubProgressMonitor(monitor, 1));
		JavaModelUtil.applyEdit(targetUnit, edits, false, new SubProgressMonitor(monitor, 1));
	} finally {
		monitor.done();
	}
}
 

private void checkOverridden(RefactoringStatus status, IProgressMonitor pm) throws JavaModelException {
	pm.beginTask("", 9); //$NON-NLS-1$
	pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden);
	MethodDeclaration decl= fSourceProvider.getDeclaration();
	IMethod method= (IMethod) decl.resolveBinding().getJavaElement();
	if (method == null || Flags.isPrivate(method.getFlags())) {
		pm.worked(8);
		return;
	}
	IType type= method.getDeclaringType();
	ITypeHierarchy hierarchy= type.newTypeHierarchy(new SubProgressMonitor(pm, 6));
	checkSubTypes(status, method, hierarchy.getAllSubtypes(type), new SubProgressMonitor(pm, 1));
	checkSuperClasses(status, method, hierarchy.getAllSuperclasses(type), new SubProgressMonitor(pm, 1));
	checkSuperInterfaces(status, method, hierarchy.getAllSuperInterfaces(type), new SubProgressMonitor(pm, 1));
	pm.setTaskName(""); //$NON-NLS-1$
}
 

public static void processFile ( final IContainer parent, final Definition definition, final Profile profile, final IProgressMonitor monitor ) throws Exception
{
    monitor.beginTask ( makeJobLabel ( definition, profile ), 100 );

    final IFolder output = parent.getFolder ( new Path ( "output" ) ); //$NON-NLS-1$
    if ( output.exists () )
    {
        output.delete ( true, new SubProgressMonitor ( monitor, 9 ) );
    }
    output.create ( true, true, new SubProgressMonitor ( monitor, 1 ) );

    final Builder builder = new Builder ( definition, profile );
    final Recipe recipe = builder.build ();

    try
    {
        final Map<String, Object> initialContent = new HashMap<String, Object> ();
        initialContent.put ( "output", output ); //$NON-NLS-1$

        recipe.execute ( initialContent, new SubProgressMonitor ( monitor, 90 ) );
    }
    finally
    {
        monitor.done ();
    }
}
 

private List<SearchResultGroup> getReferencesToTypesInPackage(IProgressMonitor pm, ReferencesInBinaryContext binaryRefs, RefactoringStatus status) throws CoreException {
	pm.beginTask("", 2); //$NON-NLS-1$
	IJavaSearchScope referencedFromNamesakesScope= RefactoringScopeFactory.create(fPackage, true, false);
	IPackageFragment[] namesakePackages= getNamesakePackages(referencedFromNamesakesScope, new SubProgressMonitor(pm, 1));
	if (namesakePackages.length == 0) {
		pm.done();
		return new ArrayList<SearchResultGroup>(0);
	}

	IJavaSearchScope scope= SearchEngine.createJavaSearchScope(namesakePackages);
	IType[] typesToSearch= getTypesInPackage(fPackage);
	if (typesToSearch.length == 0) {
		pm.done();
		return new ArrayList<SearchResultGroup>(0);
	}
	SearchPattern pattern= RefactoringSearchEngine.createOrPattern(typesToSearch, IJavaSearchConstants.REFERENCES);
	CollectingSearchRequestor requestor= new CuCollectingSearchRequestor(binaryRefs);
	SearchResultGroup[] results= RefactoringSearchEngine.search(pattern, scope, requestor, new SubProgressMonitor(pm, 1), status);
	pm.done();
	return new ArrayList<SearchResultGroup>(Arrays.asList(results));
}
 

@Override
public void beginTask(final String name, final int total) {
	endTask();
	msg = name;
	lastWorked = 0;
	totalWork = total;
	task = new SubProgressMonitor(root, 1000);
	if (totalWork == UNKNOWN)
		task.beginTask(EMPTY_STRING, IProgressMonitor.UNKNOWN);
	else
		task.beginTask(EMPTY_STRING, totalWork);
	task.subTask(msg);

	if (job != null) {
		job.setTaskTotal(total);
		job.setTaskMessage(msg);
	}
}
 

/**
 * 删除重复文本段 删除重复的TU，原文和译文相同。删除时如果TU中只有2个TUV，则直接删除TU；如果TU中有超过2个TUV则只删除当前TUV 保留最新的TUV
 * @return ;
 */
public boolean deleteDupaicate(IProgressMonitor monitor, boolean ignoreTag, boolean ignoreCase) {
	monitor.beginTask("", 100);
	SubProgressMonitor subFilerJob = new SubProgressMonitor(monitor, 40);
	subFilerJob.setTaskName(Messages.getString("core.fileAccess.filterDupliacteSegment"));
	TmxFilterQueryUtil filterQuery = new TmxFilterQueryUtil(container, super.currSrcLang, super.currTgtLang);
	filterQuery.setIngoreTag(ignoreTag);
	filterQuery.setIgnoreCase(ignoreCase);
	List<String> filterResultList = filterQuery.getDuplicate4DeleteIds(subFilerJob);
	subFilerJob.done();
	if (filterResultList.size() == 0) {
		return false;
	}

	SubProgressMonitor subDeleteJob = new SubProgressMonitor(monitor, 60);
	subDeleteJob.setTaskName(Messages.getString("core.fileAccess.deleteDuplicateSegment"));
	deleteTus(filterResultList.toArray(new String[] {}), subDeleteJob);
	subDeleteJob.done();

	return true;
}
 

/**
 * Searches for references to the identifier in the request.
 *
 * <p>{@link #prepareSearch(RefactoringRequest)} must be called before
 * {@link #search(RefactoringRequest)} or else results are undefined.
 *
 * @param request the search request
 * @throws SearchException if an exception occurs in the process of finding references.
 * @throws OperationCanceledException if the request is canceled.
 */
public void search(RefactoringRequest request)
        throws SearchException, OperationCanceledException {
    for (IRefactorRenameProcess p : requestToProcesses.get(request)) {
        request.checkCancelled();
        p.clear(); // Clear references found from a previous invocation
        RefactoringStatus status = new RefactoringStatus();
        request.pushMonitor(new SubProgressMonitor(request.getMonitor(), 1));
        try {
            p.findReferencesToRename(request, status);
        } finally {
            request.popMonitor().done();
        }
        if (status.hasFatalError()) {
            throw new SearchException(status.getEntryWithHighestSeverity().getMessage());
        }
    }
}
 

private void addMethodStubForAbstractMethod(final IMethod sourceMethod, final CompilationUnit declaringCuNode, final AbstractTypeDeclaration typeToCreateStubIn, final ICompilationUnit newCu, final CompilationUnitRewrite rewriter, final Map<IMember, IncomingMemberVisibilityAdjustment> adjustments, final IProgressMonitor monitor, final RefactoringStatus status) throws CoreException {
	final MethodDeclaration methodToCreateStubFor= ASTNodeSearchUtil.getMethodDeclarationNode(sourceMethod, declaringCuNode);
	final AST ast= rewriter.getRoot().getAST();
	final MethodDeclaration newMethod= ast.newMethodDeclaration();
	newMethod.setBody(createMethodStub(methodToCreateStubFor, ast));
	newMethod.setConstructor(false);
	copyExtraDimensions(methodToCreateStubFor, newMethod);
	newMethod.modifiers().addAll(ASTNodeFactory.newModifiers(ast, getModifiersWithUpdatedVisibility(sourceMethod, JdtFlags.clearFlag(Modifier.NATIVE | Modifier.ABSTRACT, methodToCreateStubFor.getModifiers()), adjustments, new SubProgressMonitor(monitor, 1), false, status)));
	newMethod.setName(((SimpleName) ASTNode.copySubtree(ast, methodToCreateStubFor.getName())));
	final TypeVariableMaplet[] mapping= TypeVariableUtil.composeMappings(TypeVariableUtil.subTypeToSuperType(getDeclaringType(), getDestinationType()), TypeVariableUtil.superTypeToInheritedType(getDestinationType(), ((IType) typeToCreateStubIn.resolveBinding().getJavaElement())));
	copyReturnType(rewriter.getASTRewrite(), getDeclaringType().getCompilationUnit(), methodToCreateStubFor, newMethod, mapping);
	copyParameters(rewriter.getASTRewrite(), getDeclaringType().getCompilationUnit(), methodToCreateStubFor, newMethod, mapping);
	copyThrownExceptions(methodToCreateStubFor, newMethod);
	newMethod.setJavadoc(createJavadocForStub(typeToCreateStubIn.getName().getIdentifier(), methodToCreateStubFor, newMethod, newCu, rewriter.getASTRewrite()));
	ImportRewriteContext context= new ContextSensitiveImportRewriteContext(typeToCreateStubIn, rewriter.getImportRewrite());
	ImportRewriteUtil.addImports(rewriter, context, newMethod, new HashMap<Name, String>(), new HashMap<Name, String>(), false);
	rewriter.getASTRewrite().getListRewrite(typeToCreateStubIn, typeToCreateStubIn.getBodyDeclarationsProperty()).insertAt(newMethod, ASTNodes.getInsertionIndex(newMethod, typeToCreateStubIn.bodyDeclarations()), rewriter.createCategorizedGroupDescription(RefactoringCoreMessages.PullUpRefactoring_add_method_stub, SET_PULL_UP));
}
 

@Override
protected RefactoringStatus doCheckFinalConditions(IProgressMonitor monitor, CheckConditionsContext context) throws CoreException, OperationCanceledException {
	Assert.isNotNull(monitor);
	Assert.isNotNull(context);
	RefactoringStatus status= new RefactoringStatus();
	try {
		monitor.beginTask("", 5); //$NON-NLS-1$
		monitor.setTaskName(RefactoringCoreMessages.RenameTypeParameterRefactoring_checking);
		status.merge(Checks.checkIfCuBroken(fTypeParameter.getDeclaringMember()));
		monitor.worked(1);
		if (!status.hasFatalError()) {
			status.merge(checkNewElementName(getNewElementName()));
			monitor.worked(1);
			monitor.setTaskName(RefactoringCoreMessages.RenameTypeParameterRefactoring_searching);
			status.merge(createRenameChanges(new SubProgressMonitor(monitor, 2)));
			monitor.setTaskName(RefactoringCoreMessages.RenameTypeParameterRefactoring_checking);
			if (status.hasFatalError()) {
				return status;
			}
			monitor.worked(1);
		}
	} finally {
		monitor.done();
	}
	return status;
}
 

/**
 * Computes the compilation units referencing the subtype to replace.
 *
 * @param type
 *            the subtype
 * @param monitor
 *            the progress monitor to use
 * @param status
 *            the refactoring status
 * @return the referenced compilation units (element type:
 *         <code>&lt;IJavaProject, Collection&lt;SearchResultGroup&gt;&gt;</code>)
 * @throws JavaModelException
 *             if an error occurs
 */
protected final Map<IJavaProject, Set<SearchResultGroup>> getReferencingCompilationUnits(final IType type, final IProgressMonitor monitor, final RefactoringStatus status) throws JavaModelException {
	try {
		monitor.beginTask("", 100); //$NON-NLS-1$
		monitor.setTaskName(RefactoringCoreMessages.SuperTypeRefactoringProcessor_creating);
		final RefactoringSearchEngine2 engine= new RefactoringSearchEngine2();
		engine.setOwner(fOwner);
		engine.setFiltering(true, true);
		engine.setStatus(status);
		engine.setScope(RefactoringScopeFactory.create(type));
		engine.setPattern(SearchPattern.createPattern(type, IJavaSearchConstants.REFERENCES, SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE));
		engine.searchPattern(new SubProgressMonitor(monitor, 100));
		@SuppressWarnings("unchecked")
		Map<IJavaProject, Set<SearchResultGroup>> result= (Map<IJavaProject, Set<SearchResultGroup>>) engine.getAffectedProjects();
		return result;
	} finally {
		monitor.done();
	}
}
 

@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
	try {
		pm.beginTask("", 6); //$NON-NLS-1$

		RefactoringStatus result = Checks.validateModifiesFiles(ResourceUtil.getFiles(new ICompilationUnit[] { fCu }), getValidationContext(), pm);
		if (result.hasFatalError()) {
			return result;
		}

		if (fCompilationUnitNode == null) {
			fCompilationUnitNode = RefactoringASTParser.parseWithASTProvider(fCu, true, new SubProgressMonitor(pm, 3));
		} else {
			pm.worked(3);
		}

		result.merge(checkSelection(new SubProgressMonitor(pm, 3)));
		if (!result.hasFatalError() && isLiteralNodeSelected()) {
			fReplaceAllOccurrences = false;
		}
		return result;

	} finally {
		pm.done();
	}
}
 

/**
 * Creates a new project in the workbench from an existing one
 * 
 * @param monitor
 * @throws CoreException
 */

void createExistingProject(IProgressMonitor monitor)
        throws CoreException {
    String projectName = project.getName();
    IProjectDescription description;

    try {
        monitor.beginTask("Creating " + projectName, 2 * 1000);

        description = ResourcesPlugin.getWorkspace()
                .loadProjectDescription(
                        new Path(directory + File.separatorChar
                                + ".project")); //$NON-NLS-1$

        description.setName(projectName);
        project.create(description, new SubProgressMonitor(monitor,
                1000));
        project.open(new SubProgressMonitor(monitor, 1000));
    } finally {
        monitor.done();
    }
}
 

public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
	if (fgFirstTime) {
		// Join the initialize after load job.
		IJobManager manager= Job.getJobManager();
		manager.join(JavaUI.ID_PLUGIN, monitor);
	}
	OpenTypeHistory history= OpenTypeHistory.getInstance();
	if (fgFirstTime || history.isEmpty()) {
		if (history.needConsistencyCheck()) {
			monitor.beginTask(JavaUIMessages.TypeSelectionDialog_progress_consistency, 100);
			refreshSearchIndices(new SubProgressMonitor(monitor, 90));
			history.checkConsistency(new SubProgressMonitor(monitor, 10));
		} else {
			refreshSearchIndices(monitor);
		}
		monitor.done();
		fgFirstTime= false;
	} else {
		history.checkConsistency(monitor);
	}
}
 

private void checkOverridden(RefactoringStatus status, IProgressMonitor pm) throws JavaModelException {
	pm.beginTask("", 9); //$NON-NLS-1$
	pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden);
	MethodDeclaration decl= fSourceProvider.getDeclaration();
	IMethod method= (IMethod) decl.resolveBinding().getJavaElement();
	if (method == null || Flags.isPrivate(method.getFlags())) {
		pm.worked(8);
		return;
	}
	IType type= method.getDeclaringType();
	ITypeHierarchy hierarchy= type.newTypeHierarchy(new SubProgressMonitor(pm, 6));
	checkSubTypes(status, method, hierarchy.getAllSubtypes(type), new SubProgressMonitor(pm, 1));
	checkSuperClasses(status, method, hierarchy.getAllSuperclasses(type), new SubProgressMonitor(pm, 1));
	checkSuperInterfaces(status, method, hierarchy.getAllSuperInterfaces(type), new SubProgressMonitor(pm, 1));
	pm.setTaskName(""); //$NON-NLS-1$
}
 

private void chooseTypes(ConstraintVariable2[] allConstraintVariables, SubProgressMonitor pm) {
	pm.beginTask("", allConstraintVariables.length); //$NON-NLS-1$
	for (int i= 0; i < allConstraintVariables.length; i++) {
		ConstraintVariable2 cv= allConstraintVariables[i];

		TypeEquivalenceSet set= cv.getTypeEquivalenceSet();
		if (set == null)
			continue; //TODO: should not happen iff all unused constraint variables got pruned
		//TODO: should calculate only once per EquivalenceRepresentative; can throw away estimate TypeSet afterwards
		TType type= chooseSingleType((TypeSet) cv.getTypeEstimate()); //TODO: is null for Universe TypeSet
		setChosenType(cv, type);

		if (cv instanceof CollectionElementVariable2) {
			CollectionElementVariable2 elementCv= (CollectionElementVariable2) cv;
			fUpdate.addDeclaration(elementCv);
		}

		pm.worked(1);
		if (pm.isCanceled())
			throw new OperationCanceledException();
	}
	pm.done();
}
 

@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
	try {
		pm.beginTask("", 6); //$NON-NLS-1$

		RefactoringStatus result= Checks.validateModifiesFiles(ResourceUtil.getFiles(new ICompilationUnit[] { fCu}), getValidationContext());
		if (result.hasFatalError())
			return result;

		if (fCompilationUnitNode == null) {
			fCompilationUnitNode= RefactoringASTParser.parseWithASTProvider(fCu, true, new SubProgressMonitor(pm, 3));
		} else {
			pm.worked(3);
		}

		result.merge(checkSelection(new SubProgressMonitor(pm, 3)));
		if (!result.hasFatalError() && isLiteralNodeSelected())
			fReplaceAllOccurrences= false;
		return result;

	} finally {
		pm.done();
	}
}
 

private List<NonNLSElement> analyze(IPackageFragmentRoot sourceFolder, IProgressMonitor pm) throws CoreException {
	try{
		IJavaElement[] children= sourceFolder.getChildren();
		pm.beginTask("", children.length); //$NON-NLS-1$
		pm.setTaskName(JavaElementLabels.getElementLabel(sourceFolder, JavaElementLabels.ALL_DEFAULT));
		List<NonNLSElement> result= new ArrayList<NonNLSElement>();
		for (int i= 0; i < children.length; i++) {
			IJavaElement iJavaElement= children[i];
			if (iJavaElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT){
				IPackageFragment pack= (IPackageFragment)iJavaElement;
				if (! pack.isReadOnly())
					result.addAll(analyze(pack, new SubProgressMonitor(pm, 1)));
				else
					pm.worked(1);
			} else
				pm.worked(1);
		}
		return result;
	} finally{
		pm.done();
	}
}
 

public boolean visit(IResourceDelta delta) throws CoreException {
	IResource resource = delta.getResource();
	// ignore all parent elements (projects, folders)
	if (resource instanceof IFile) {
		switch (delta.getKind()) {
		case IResourceDelta.ADDED:
			// handle added resource
			processResource(resource,
					new SubProgressMonitor(monitor, 1));
			break;
		case IResourceDelta.REMOVED:
			// resources are not available any more and therefore the
			// markers were automatically removed
			break;
		case IResourceDelta.CHANGED:
			// handle changed resource
			processResource(resource,
					new SubProgressMonitor(monitor, 1));
			break;
		}
	}
	// return true to continue visiting children.
	return true;
}
 

private void addNecessaryMethodStubs(final List<IType> affected, final CompilationUnit root, final CompilationUnitRewrite unitRewriter, final Map<IMember, IncomingMemberVisibilityAdjustment> adjustments, final IProgressMonitor monitor, final RefactoringStatus status) throws CoreException {
	final IType declaringType= getDeclaringType();
	final IMethod[] methods= getAbstractMethods();
	try {
		monitor.beginTask(RefactoringCoreMessages.PullUpRefactoring_checking, affected.size());
		for (final Iterator<IType> iter= affected.iterator(); iter.hasNext();) {
			final IType type= iter.next();
			if (type.equals(declaringType))
				continue;
			final AbstractTypeDeclaration declaration= ASTNodeSearchUtil.getAbstractTypeDeclarationNode(type, unitRewriter.getRoot());
			final ICompilationUnit unit= type.getCompilationUnit();
			final IProgressMonitor subMonitor= new SubProgressMonitor(monitor, 1);
			try {
				subMonitor.beginTask(RefactoringCoreMessages.PullUpRefactoring_checking, methods.length);
				for (int j= 0; j < methods.length; j++) {
					final IMethod method= methods[j];
					if (null == JavaModelUtil.findMethod(method.getElementName(), method.getParameterTypes(), method.isConstructor(), type)) {
						addMethodStubForAbstractMethod(method, root, declaration, unit, unitRewriter, adjustments, new SubProgressMonitor(subMonitor, 1), status);
					}
				}
				subMonitor.done();
			} finally {
				subMonitor.done();
			}
		}
	} finally {
		monitor.done();
	}
}
 

private IType[] findTypesWithMissingUID(IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor) throws CoreException {
	try {
		monitor.beginTask("", compilationUnits.length); //$NON-NLS-1$

		IType serializable= project.findType(SERIALIZABLE_NAME);

		List<IType> types= new ArrayList<IType>();

		if (compilationUnits.length > 500) {
			//500 is a guess. Building the type hierarchy on serializable is very expensive
			//depending on how many subtypes exit in the project.

			HashSet<ICompilationUnit> cus= new HashSet<ICompilationUnit>();
			for (int i= 0; i < compilationUnits.length; i++) {
				cus.add(compilationUnits[i]);
			}

			monitor.subTask(Messages.format(FixMessages.Java50Fix_SerialVersion_CalculateHierarchy_description, SERIALIZABLE_NAME));
			ITypeHierarchy hierarchy1= serializable.newTypeHierarchy(project, new SubProgressMonitor(monitor, compilationUnits.length));
			IType[] allSubtypes1= hierarchy1.getAllSubtypes(serializable);
			addTypes(allSubtypes1, cus, types);
		} else {
			monitor.subTask(FixMessages.Java50Fix_InitializeSerialVersionId_subtask_description);
                  for (int i= 0; i < compilationUnits.length; i++) {
                  	collectChildrenWithMissingSerialVersionId(compilationUnits[i].getChildren(), serializable, types);
                  	if (monitor.isCanceled())
                  		throw new OperationCanceledException();
                  	monitor.worked(1);
                  }
		}

		return types.toArray(new IType[types.size()]);
	} finally {
		monitor.done();
	}
}
 

private void deleteFolders(List<IFolder> folders, IProgressMonitor monitor) throws CoreException {
	try {
		monitor.beginTask(NewWizardMessages.ClasspathModifier_Monitor_RemoveFromBuildpath, folders.size());

		for (Iterator<IFolder> iter= folders.iterator(); iter.hasNext();) {
			IFolder folder= iter.next();
			folder.delete(true, true, new SubProgressMonitor(monitor, 1));
		}
	} finally {
		monitor.done();
	}
}
 

@Override
public Change createChange(IProgressMonitor pm) throws CoreException {
	try {
		checkParameters();

		pm.beginTask("", 3); //$NON-NLS-1$

		final DynamicValidationStateChange result= new DynamicValidationStateChange(NLSMessages.NLSRefactoring_change_name);

		boolean createAccessorClass= willCreateAccessorClass();
		if (NLSSubstitution.countItems(fSubstitutions, NLSSubstitution.EXTERNALIZED) == 0) {
			createAccessorClass= false;
		}
		if (createAccessorClass) {
			result.add(AccessorClassCreator.create(fCu, fAccessorClassName, getAccessorCUPath(), fAccessorClassPackage, getPropertyFilePath(), fIsEclipseNLS, fSubstitutions, getSubstitutionPattern(), new SubProgressMonitor(pm, 1)));
		}
		pm.worked(1);

		if (willModifySource()) {
			result.add(NLSSourceModifier.create(getCu(), fSubstitutions, getSubstitutionPattern(), fAccessorClassPackage, fAccessorClassName, fIsEclipseNLS));
		}
		pm.worked(1);

		if (willModifyPropertyFile()) {
			result.add(NLSPropertyFileModifier.create(fSubstitutions, getPropertyFilePath()));
			if (isEclipseNLS() && !createAccessorClass) {
				Change change= AccessorClassModifier.create(getAccessorCu(), fSubstitutions);
				if (change != null)
					result.add(change);
			}
		}
		pm.worked(1);

		return result;
	} finally {
		pm.done();
	}
}
 

private RefactoringStatus checkReferencesToPushedDownMembers(IProgressMonitor monitor) throws JavaModelException {
	List<IMember> fields= new ArrayList<IMember>(fMemberInfos.length);
	for (int index= 0; index < fMemberInfos.length; index++) {
		MemberActionInfo info= fMemberInfos[index];
		if (info.isToBePushedDown())
			fields.add(info.getMember());
	}
	IMember[] membersToPush= fields.toArray(new IMember[fields.size()]);
	RefactoringStatus result= new RefactoringStatus();
	List<IMember> movedMembers= Arrays.asList(MemberActionInfo.getMembers(getInfosForMembersToBeCreatedInSubclassesOfDeclaringClass()));
	monitor.beginTask(RefactoringCoreMessages.PushDownRefactoring_check_references, membersToPush.length);
	for (int index= 0; index < membersToPush.length; index++) {
		IMember member= membersToPush[index];
		String label= createLabel(member);
		IJavaElement[] referencing= getReferencingElementsFromSameClass(member, new SubProgressMonitor(monitor, 1), result);
		for (int offset= 0; offset < referencing.length; offset++) {
			IJavaElement element= referencing[offset];
			if (movedMembers.contains(element))
				continue;
			if (!(element instanceof IMember))
				continue;
			IMember referencingMember= (IMember) element;
			Object[] keys= { label, createLabel(referencingMember) };
			String msg= Messages.format(RefactoringCoreMessages.PushDownRefactoring_referenced, keys);
			result.addError(msg, JavaStatusContext.create(referencingMember));
		}
	}
	monitor.done();
	return result;
}
 

/**
 * Checks if the refactoring can be activated. Activation typically means, if a
 * corresponding menu entry can be added to the UI.
 *
 * @param pm a progress monitor to report progress during activation checking.
 * @return the refactoring status describing the result of the activation check.
 * @throws CoreException if checking fails
 */
@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
	RefactoringStatus result= new RefactoringStatus();
	pm.beginTask("", 100); //$NON-NLS-1$

	if (fSelectionStart < 0 || fSelectionLength == 0)
		return mergeTextSelectionStatus(result);

	IFile[] changedFiles= ResourceUtil.getFiles(new ICompilationUnit[]{fCUnit});
	result.merge(Checks.validateModifiesFiles(changedFiles, getValidationContext()));
	if (result.hasFatalError())
		return result;
	result.merge(ResourceChangeChecker.checkFilesToBeChanged(changedFiles, new SubProgressMonitor(pm, 1)));

	if (fRoot == null) {
		fRoot= RefactoringASTParser.parseWithASTProvider(fCUnit, true, new SubProgressMonitor(pm, 99));
	}
	fImportRewriter= StubUtility.createImportRewrite(fRoot, true);

	fAST= fRoot.getAST();
	fRoot.accept(createVisitor());

	fSelectionStart= fAnalyzer.getSelection().getOffset();
	fSelectionLength= fAnalyzer.getSelection().getLength();

	result.merge(fAnalyzer.checkInitialConditions(fImportRewriter));
	if (result.hasFatalError())
		return result;
	if (fVisibility == -1) {
		setVisibility(Modifier.PRIVATE);
	}
	initializeParameterInfos();
	initializeUsedNames();
	initializeDuplicates();
	initializeDestinations();
	return result;
}
 

public IMember[] getAdditionalRequiredMembers(IProgressMonitor monitor) throws JavaModelException {
	IMember[] members= MemberActionInfo.getMembers(getInfosForMembersToBeCreatedInSubclassesOfDeclaringClass());
	monitor.beginTask(RefactoringCoreMessages.PushDownRefactoring_calculating_required, members.length);// not
	// true,
	// but
	// not
	// easy
	// to
	// give
	// anything
	// better
	List<IMember> queue= new ArrayList<IMember>(members.length);
	queue.addAll(Arrays.asList(members));
	if (queue.isEmpty())
		return new IMember[0];
	int i= 0;
	IMember current;
	do {
		current= queue.get(i);
		addAllRequiredPushableMembers(queue, current, new SubProgressMonitor(monitor, 1));
		i++;
		if (queue.size() == i)
			current= null;
	} while (current != null);
	queue.removeAll(Arrays.asList(members));// report only additional
	return queue.toArray(new IMember[queue.size()]);
}
 

private List<SearchResultGroup> getReferencesToTypesInNamesakes(IProgressMonitor pm, RefactoringStatus status) throws CoreException {
	pm.beginTask("", 2); //$NON-NLS-1$
	// e.g. renaming B-p.p; project C requires B, X and has ref to B-p.p and X-p.p;
	// goal: find refs to X-p.p in CUs from fOccurrences

	// (1) find namesake packages (scope: all packages referenced by CUs in fOccurrences and fPackage)
	IJavaElement[] elements= new IJavaElement[fOccurrences.length + 1];
	for (int i= 0; i < fOccurrences.length; i++) {
		elements[i]= fOccurrences[i].getCompilationUnit();
	}
	elements[fOccurrences.length]= fPackage;
	IJavaSearchScope namesakePackagesScope= RefactoringScopeFactory.createReferencedScope(elements);
	IPackageFragment[] namesakePackages= getNamesakePackages(namesakePackagesScope, new SubProgressMonitor(pm, 1));
	if (namesakePackages.length == 0) {
		pm.done();
		return new ArrayList<SearchResultGroup>(0);
	}

	// (2) find refs in fOccurrences and fPackage to namesake packages
	// (from fOccurrences (without namesakes): may have shared star import)
	// (from fPackage: may have unimported references to types of namesake packages)
	IType[] typesToSearch= getTypesInPackages(namesakePackages);
	if (typesToSearch.length == 0) {
		pm.done();
		return new ArrayList<SearchResultGroup>(0);
	}
	SearchPattern pattern= RefactoringSearchEngine.createOrPattern(typesToSearch, IJavaSearchConstants.REFERENCES);
	IJavaSearchScope scope= getPackageAndOccurrencesWithoutNamesakesScope();
	SearchResultGroup[] results= RefactoringSearchEngine.search(pattern, scope, new SubProgressMonitor(pm, 1), status);
	pm.done();
	return new ArrayList<SearchResultGroup>(Arrays.asList(results));
}
 

private static SearchMatch[] getFieldReferencesIn(IJavaElement[] elements, WorkingCopyOwner owner, IProgressMonitor pm) throws JavaModelException {
	List<SearchMatch> referencedFields= new ArrayList<>();
	pm.beginTask("", elements.length); //$NON-NLS-1$
	for (int i = 0; i < elements.length; i++) {
		referencedFields.addAll(getFieldReferencesIn(elements[i], owner, new SubProgressMonitor(pm, 1)));
	}
	pm.done();
	return referencedFields.toArray(new SearchMatch[referencedFields.size()]);
}
 

@Override
public RefactoringStatus checkInitialConditions(IProgressMonitor monitor) throws CoreException {
	RefactoringStatus result= super.checkInitialConditions(monitor);
	if (result.hasFatalError()) {
		return result;
	}
	try{
		monitor.beginTask("", 3); //$NON-NLS-1$
		if (!fActivationChecked) {
			// the following code may change the method to be changed.
			IMethod method= getMethod();
			fOriginalMethod= method;

			ITypeHierarchy hierarchy= null;
			IType declaringType= method.getDeclaringType();
			if (!declaringType.isInterface()) {
				hierarchy= getCachedHierarchy(declaringType, new SubProgressMonitor(monitor, 1));
			}

			IMethod topmost= getMethod();
			if (MethodChecks.isVirtual(topmost)) {
				topmost= MethodChecks.getTopmostMethod(getMethod(), hierarchy, monitor);
			}
			if (topmost != null) {
				initialize(topmost);
			}
			fActivationChecked= true;
		}
	} finally{
		monitor.done();
	}
	return result;
}