Java ProcessorBasedRefactoring类代码示例

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
public static ProcessorBasedRefactoring createRefactoring(IMethod[] methods, Optional<IProgressMonitor> monitor)
		throws JavaModelException {
	IJavaProject project = null;

	if (methods != null && methods.length > 0)
		project = methods[0].getJavaProject();

	return createRefactoring(project, methods, monitor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
protected boolean isApplicable(Shell parent, ProcessorBasedRefactoring refactoring) {
	try {
		if (refactoring.isApplicable()) {
			return true;
		}
		showFatalErrorMessage(parent, "Refactoring is not applicable");
	} catch (CoreException e) {
		LOG.error("Error detecting applicability of refactoring", e);
		showFatalErrorMessage(parent, "Cannot apply refactoring. See log for details.");
	}
	return false;
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
public ProcessorBasedRefactoring getRenameRefactoring(IRenameElementContext renameElementContext) {
	RenameProcessor processor = getRenameProcessor(renameElementContext);
	if (processor != null) {
		return new RenameRefactoring(processor);
	}
	return null;
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
private void helper1(String[] newNames, String[] signature) throws Exception {
  ICompilationUnit cu = createCUfromTestFile(getPackageP(), true, true);
  IType classA = getType(cu, "A");
  IMethod method = classA.getMethod("m", signature);
  Assert.assertTrue(
      "refactoring not available",
      RefactoringAvailabilityTester.isChangeSignatureAvailable(method));
  ChangeSignatureProcessor processor = new ChangeSignatureProcessor(method);
  Refactoring ref = new ProcessorBasedRefactoring(processor);
  // ref.setUpdateReferences(updateReferences);
  // ref.setNewParameterNames(newNames);
  // ref.setNewNames(createRenamings(method, newNames));
  modifyInfos(processor.getParameterInfos(), newNames);

  RefactoringStatus result = performRefactoring(ref);
  Assert.assertEquals("precondition was supposed to pass", null, result);

  IPackageFragment pack = (IPackageFragment) cu.getParent();
  String newCuName = getSimpleTestFileName(true, true);
  ICompilationUnit newcu = pack.getCompilationUnit(newCuName);
  Assert.assertTrue(newCuName + " does not exist", newcu.exists());
  Assert.assertEquals(
      "invalid renaming",
      getFileContents(getTestFileName(true, false)).length(),
      newcu.getSource().length());
  assertEqualLines(
      "invalid renaming", getFileContents(getTestFileName(true, false)), newcu.getSource());
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
private void helper2(String[] newNames, String[] signature) throws Exception {
  IType classA = getType(createCUfromTestFile(getPackageP(), false, false), "A");
  // DebugUtils.dump("classA" + classA);
  IMethod method = classA.getMethod("m", signature);
  Assert.assertTrue(
      "refactoring not available",
      RefactoringAvailabilityTester.isChangeSignatureAvailable(method));
  ChangeSignatureProcessor processor = new ChangeSignatureProcessor(method);
  Refactoring ref = new ProcessorBasedRefactoring(processor);
  modifyInfos(processor.getParameterInfos(), newNames);

  RefactoringStatus result = performRefactoring(ref);
  Assert.assertNotNull("precondition was supposed to fail", result);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
private Change createChangeForMethodRename(IMethod methodToRename)
    throws RefactoringException {
  MethodRenameChangeBuilder builder = new MethodRenameChangeBuilder(
      methodToRename, newMethodName, processor,
      methodToRename.getJavaProject().getProject().getWorkspace());

  ProcessorBasedRefactoring refactoring = (ProcessorBasedRefactoring) builder.createRefactoring();
  RefactoringProcessor nestedProcessor = refactoring.getProcessor();
  NestedRefactoringContext.storeForProcessor(
      nestedProcessor,
      MethodRenameRefactoringContext.newNestedRefactoringContext(refactoringContext));

  return builder.createChange();
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
private Change createChangeForInterfaceRename() throws RefactoringException {
  InterfaceRenameChangeBuilder builder = new InterfaceRenameChangeBuilder(
      typeContainer.getPairedType(),
      pairedNewName,
      processor,
      typeContainer.getPairedType().getJavaProject().getProject().getWorkspace());

  ProcessorBasedRefactoring refactoring = (ProcessorBasedRefactoring) builder.createRefactoring();
  RefactoringProcessor nestedProcessor = refactoring.getProcessor();
  NestedRefactoringContext.storeForProcessor(
      nestedProcessor,
      InterfaceRenameRefactoringContext.newNestedRefactoringContext(typeContainer.getBaseType()));

  return builder.createChange();
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	PushDownRefactoringProcessor processor= new PushDownRefactoringProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	UseSuperTypeProcessor processor= new UseSuperTypeProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	PullUpRefactoringProcessor processor= new PullUpRefactoringProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	ExtractSupertypeProcessor processor= new ExtractSupertypeProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
@Override
public Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	if (descriptor instanceof IntroduceParameterObjectDescriptor) {
		IntroduceParameterObjectProcessor processor= new IntroduceParameterObjectProcessor((IntroduceParameterObjectDescriptor) descriptor);
		return new ProcessorBasedRefactoring(processor);
	}
	return null;
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	ChangeSignatureProcessor processor= new ChangeSignatureProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Refactoring createRefactoring(JavaRefactoringDescriptor descriptor, RefactoringStatus status) throws CoreException {
	JavaRefactoringArguments arguments= new JavaRefactoringArguments(descriptor.getProject(), retrieveArgumentMap(descriptor));
	ExtractInterfaceProcessor processor= new ExtractInterfaceProcessor(arguments, status);
	return new ProcessorBasedRefactoring(processor);
}
 

import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring; //导入依赖的package包/类
public static void startChangeSignatureRefactoring(final IMethod method, final SelectionDispatchAction action, final Shell shell) throws JavaModelException {
	if (!RefactoringAvailabilityTester.isChangeSignatureAvailable(method))
		return;
	try {
		ChangeSignatureProcessor processor= new ChangeSignatureProcessor(method);
		RefactoringStatus status= processor.checkInitialConditions(new NullProgressMonitor());
		if (status.hasFatalError()) {
			final RefactoringStatusEntry entry= status.getEntryMatchingSeverity(RefactoringStatus.FATAL);
			if (entry.getCode() == RefactoringStatusCodes.OVERRIDES_ANOTHER_METHOD || entry.getCode() == RefactoringStatusCodes.METHOD_DECLARED_IN_INTERFACE) {
				Object element= entry.getData();
				if (element != null) {
					String message= Messages.format(RefactoringMessages.RefactoringErrorDialogUtil_okToPerformQuestion, entry.getMessage());
					if (MessageDialog.openQuestion(shell, RefactoringMessages.OpenRefactoringWizardAction_refactoring, message)) {
						IStructuredSelection selection= new StructuredSelection(element);
						// TODO: should not hijack this
						// ModifiyParametersAction.
						// The action is set up on an editor, but we use it
						// as if it were set up on a ViewPart.
						boolean wasEnabled= action.isEnabled();
						action.selectionChanged(selection);
						if (action.isEnabled()) {
							action.run(selection);
						} else {
							MessageDialog.openInformation(shell, ActionMessages.ModifyParameterAction_problem_title, ActionMessages.ModifyParameterAction_problem_message);
						}
						action.setEnabled(wasEnabled);
					}
				}
				return;
			}
		}

		Refactoring refactoring= new ProcessorBasedRefactoring(processor);
		ChangeSignatureWizard wizard= new ChangeSignatureWizard(processor, refactoring);
		new RefactoringStarter().activate(wizard, shell, wizard.getDefaultPageTitle(), RefactoringSaveHelper.SAVE_REFACTORING);
	} catch (CoreException e) {
		ExceptionHandler.handle(e, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringMessages.RefactoringStarter_unexpected_exception);
	}
}