Java RefactoringContribution类代码示例

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/** {@inheritDoc} */
public Refactoring createRefactoring(final RefactoringStatus status) throws CoreException {
  Refactoring refactoring = null;
  final String id = getID();
  final RefactoringContribution contribution = RefactoringCore.getRefactoringContribution(id);
  if (contribution != null) {
    if (contribution instanceof JavaRefactoringContribution) {
      JavaRefactoringContribution javaContribution = (JavaRefactoringContribution) contribution;
      refactoring = javaContribution.createRefactoring(this, status);
    } else
      JavaPlugin.log(
          new Status(
              IStatus.ERROR,
              JavaPlugin.getPluginId(),
              0,
              MessageFormat.format(
                  DescriptorMessages.JavaRefactoringDescriptor_no_resulting_descriptor,
                  new Object[] {id}),
              null));
  }
  return refactoring;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Creates a new refactoring descriptor for the specified input data.
 *
 * @param id the unique id of the refactoring
 * @param project the project name, or <code>null</code>
 * @param description a description
 * @param comment the comment, or <code>null</code>
 * @param arguments the argument map
 * @param flags the flags
 * @return the refactoring descriptor
 * @throws IllegalArgumentException if the argument map contains invalid keys/values
 */
public RefactoringDescriptor createDescriptor(
    final String id,
    final String project,
    final String description,
    final String comment,
    final Map arguments,
    final int flags)
    throws IllegalArgumentException {
  Assert.isNotNull(id);
  Assert.isNotNull(description);
  Assert.isNotNull(arguments);
  Assert.isLegal(flags >= RefactoringDescriptor.NONE);
  final RefactoringContribution contribution = getRefactoringContribution(id);
  if (contribution != null)
    return contribution.createDescriptor(id, project, description, comment, arguments, flags);
  return new DefaultRefactoringDescriptor(id, project, description, comment, arguments, flags);
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Creates a {@link RefactoringDescriptor} from a
 * {@link RefactoringContribution} of the given ID.
 * 
 * @return a non-null {@link RefactoringDescriptor}
 * @throws RefactoringException if there was a problem creating the descriptor
 */
public static RefactoringDescriptor createDescriptor(String contributionId)
    throws RefactoringException {
  RefactoringContribution contribution = RefactoringCore.getRefactoringContribution(contributionId);
  if (contribution == null) {
    throw new RefactoringException(
        String.format("The refactoring contribution (%s) is not available.",
            contributionId));
  }

  RefactoringDescriptor refactoringDescriptor = contribution.createDescriptor();
  if (refactoringDescriptor == null) {
    throw new RefactoringException(
        String.format(
            "A descriptor could not be created from the refactoring contribution (%s).",
            contribution.getClass().getSimpleName()));
  }

  return refactoringDescriptor;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
private IntroduceParameterDescriptor getRefactoringDescriptor() {
	ChangeMethodSignatureDescriptor extended= (ChangeMethodSignatureDescriptor) fChangeSignatureProcessor.createDescriptor();
	RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(IJavaRefactorings.CHANGE_METHOD_SIGNATURE);

	Map<String, String> argumentsMap= contribution.retrieveArgumentMap(extended);

	final Map<String, String> arguments= new HashMap<String, String>();
	arguments.put(ATTRIBUTE_ARGUMENT, fParameter.getNewName());
	arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION, new Integer(fSelectionStart).toString() + " " + new Integer(fSelectionLength).toString()); //$NON-NLS-1$
	arguments.putAll(argumentsMap);
	String signature= fChangeSignatureProcessor.getMethodName();
	try {
		signature= fChangeSignatureProcessor.getOldMethodSignature();
	} catch (JavaModelException exception) {
		JavaPlugin.log(exception);
	}
	final String description= Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_descriptor_description_short, BasicElementLabels.getJavaElementName(fChangeSignatureProcessor.getMethod().getElementName()));
	final String header= Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_descriptor_description, new String[] { BasicElementLabels.getJavaElementName(fParameter.getNewName()), signature, BasicElementLabels.getJavaCodeString(ASTNodes.asString(fSelectedExpression))});
	final JDTRefactoringDescriptorComment comment= new JDTRefactoringDescriptorComment(extended.getProject(), this, header);
	comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_original_pattern, JavaElementLabels.getTextLabel(fChangeSignatureProcessor.getMethod(),
			JavaElementLabels.ALL_FULLY_QUALIFIED)));
	comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_expression_pattern, BasicElementLabels.getJavaCodeString(ASTNodes.asString(fSelectedExpression))));
	comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_parameter_pattern, BasicElementLabels.getJavaElementName(getAddedParameterInfo().getNewName())));
	return RefactoringSignatureDescriptorFactory.createIntroduceParameterDescriptor(extended.getProject(), description, comment.asString(), arguments, extended.getFlags());
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
public static void renameVariable(String task, IJavaElement element, String new_name) {
    RefactoringStatus status = new RefactoringStatus();

    RefactoringContribution contrib = RefactoringCore
            .getRefactoringContribution(IJavaRefactorings.RENAME_LOCAL_VARIABLE);
    RenameJavaElementDescriptor rnDesc = (RenameJavaElementDescriptor) contrib.createDescriptor();
    rnDesc.setFlags(JavaRefactoringDescriptor.JAR_MIGRATION | JavaRefactoringDescriptor.JAR_REFACTORING);
    rnDesc.setProject(element.getJavaProject().getProject().getName());
    rnDesc.setUpdateReferences(true);
    rnDesc.setJavaElement(element);
    rnDesc.setNewName(new_name);

    Refactoring ref;
    try {
        ref = rnDesc.createRefactoring(status);
        ref.checkInitialConditions(NULL_MON);
        ref.checkFinalConditions(NULL_MON);

        Change change = ref.createChange(NULL_MON);
        change.perform(NULL_MON);
    } catch (CoreException e) {
        e.printStackTrace();
    }

}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
@Override
public void executionNotification(RefactoringExecutionEvent event) {
	refactoringName = getRefactoringID(event);
	int refactoringEventType = event.getEventType();
	RefactoringDescriptor refactoringDescriptor = getRefactoringDescriptorFromEvent(event);
	RefactoringContribution refactoringContribution = RefactoringCore.getRefactoringContribution(refactoringName);
	Map argumentMap = refactoringContribution.retrieveArgumentMap(refactoringDescriptor);
	
	if (refactoringEventType == RefactoringExecutionEvent.ABOUT_TO_PERFORM || refactoringEventType == RefactoringExecutionEvent.ABOUT_TO_REDO) {
		isRefactoringInProgress = true;
		clientRecorder.recordRefactoring(refactoringName, argumentMap);
	}
	
	if (refactoringEventType == RefactoringExecutionEvent.ABOUT_TO_UNDO) {
		isRefactoringInProgress = true;
		clientRecorder.recordRefactoringUndo(refactoringName, argumentMap);
	}
	
	if (refactoringEventType == RefactoringExecutionEvent.PERFORMED || refactoringEventType == RefactoringExecutionEvent.REDONE || refactoringEventType == RefactoringExecutionEvent.UNDONE) {
		isRefactoringInProgress = false;
		clientRecorder.recordRefactoringEnd(refactoringName, argumentMap);
		refactoringName = "";
	}
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Returns the argument map of the specified descriptor.
 *
 * @param descriptor the refactoring descriptor
 * @return the argument map, or <code>null</code>
 */
public static Map getArgumentMap(final RefactoringDescriptor descriptor) {
  Map arguments = null;
  final RefactoringContribution contribution =
      RefactoringContributionManager.getInstance().getRefactoringContribution(descriptor.getID());
  if (contribution != null) arguments = contribution.retrieveArgumentMap(descriptor);
  else if (descriptor instanceof DefaultRefactoringDescriptor)
    arguments = ((DefaultRefactoringDescriptor) descriptor).getArguments();
  return arguments;
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
@Override
public Change perform(IProgressMonitor pm) throws CoreException {

	RefactoringContribution refactoringContribution = RefactoringCore
			.getRefactoringContribution(IJavaRefactorings.MOVE);
	RefactoringDescriptor desc = refactoringContribution.createDescriptor();
	MoveDescriptor moveDes = (MoveDescriptor) desc;
	moveDes.setComment("Moving " + originalFile);
	moveDes.setDescription("Moving " + originalFile);
	IFolder dest = computeCompilationUnitDestination();
	moveDes.setDestination(JavaCore.create(dest));
	moveDes.setProject(originalFile.getProject().getName());
 
	moveDes.setMoveResources(new IFile[0], new IFolder[0],
			new ICompilationUnit[] { JavaCore.createCompilationUnitFrom(originalFile) });
	moveDes.setUpdateReferences(true);

	RefactoringStatus status = new RefactoringStatus();

	RefactoringContext context = moveDes.createRefactoringContext(status);
	PerformRefactoringOperation op = new PerformRefactoringOperation(context,
			CheckConditionsOperation.ALL_CONDITIONS);
	Job job = new WorkspaceJob("GW4E Moving Job") {
		@Override
		public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
			Display.getDefault().syncExec(() -> {
				try {
					
					op.run(monitor);
				} catch (Exception e) {
					ResourceManager.logException(e);
				}
			});
			return Status.OK_STATUS;
		}
	};
	job.setRule(originalFile.getProject()); // lock so that we serialize the
											// refactoring of the "test
											// interface" AND the "test
											// implementation"
	job.setUser(true);
	job.schedule();

	return op.getUndoChange();
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Populates the refactoring contribution cache if necessary.
 *
 * @since 3.3
 */
private void populateCache() {
  if (fContributionCache == null || fIdCache == null) {
    fContributionCache = new HashMap(32);
    fIdCache = new HashMap(32);
    Map<String, String> contributions = CheRefactoringContributions.getRefactoringContributions();
    contributions.forEach(
        (id, clazz) -> {
          try {
            final Object implementation =
                CheRefactoringContributions.createExecutableExtension(clazz);
            if (implementation instanceof RefactoringContribution) {
              if (fContributionCache.get(id) != null)
                RefactoringCorePlugin.logErrorMessage(
                    Messages.format(
                        RefactoringCoreMessages.RefactoringCorePlugin_duplicate_warning,
                        new String[] {id, clazz}));
              fContributionCache.put(id, implementation);
              fIdCache.put(implementation, id);
            } else
              RefactoringCorePlugin.logErrorMessage(
                  Messages.format(
                      RefactoringCoreMessages.RefactoringCorePlugin_creation_error,
                      new String[] {id, clazz}));
          } catch (CoreException exception) {
            RefactoringCorePlugin.log(exception);
          }
        });
    //			final IConfigurationElement[] elements=
    // Platform.getExtensionRegistry().getConfigurationElementsFor(RefactoringCore.ID_PLUGIN,
    // REFACTORING_CONTRIBUTIONS_EXTENSION_POINT);
    //			for (int index= 0; index < elements.length; index++) {
    //				final IConfigurationElement element= elements[index];
    //				final String attributeId= element.getAttribute(ATTRIBUTE_ID);
    //				final String point= RefactoringCore.ID_PLUGIN + "." +
    // REFACTORING_CONTRIBUTIONS_EXTENSION_POINT; //$NON-NLS-1$
    //				if (attributeId != null && !"".equals(attributeId)) { //$NON-NLS-1$
    //					final String className= element.getAttribute(ATTRIBUTE_CLASS);
    //					if (className != null && !"".equals(className)) { //$NON-NLS-1$
    //						try {
    //							final Object implementation= element.createExecutableExtension(ATTRIBUTE_CLASS);
    //							if (implementation instanceof RefactoringContribution) {
    //								if (fContributionCache.get(attributeId) != null)
    //									RefactoringCorePlugin.logErrorMessage(Messages.format(RefactoringCoreMessages
    // .RefactoringCorePlugin_duplicate_warning, new String[] { attributeId, point}));
    //								fContributionCache.put(attributeId, implementation);
    //								fIdCache.put(implementation, attributeId);
    //							} else
    //
    //	RefactoringCorePlugin.logErrorMessage(Messages.format(RefactoringCoreMessages.RefactoringCorePlugin_creation_error, new String[] { point, attributeId}));
    //						} catch (CoreException exception) {
    //							RefactoringCorePlugin.log(exception);
    //						}
    //					} else
    //
    //	RefactoringCorePlugin.logErrorMessage(Messages.format(RefactoringCoreMessages.RefactoringCorePlugin_missing_class_attribute, new String[] { point, attributeId, ATTRIBUTE_CLASS}));
    //				} else
    //
    //	RefactoringCorePlugin.logErrorMessage(Messages.format(RefactoringCoreMessages.RefactoringCorePlugin_missing_attribute, new String[] { point, ATTRIBUTE_ID}));
    //			}
  }
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected RefactoringContext createRefactoringContext(RefactoringDescriptor descriptor, RefactoringStatus status, IProgressMonitor monitor) throws CoreException {
	Assert.isNotNull(descriptor);

	createNecessarySourceCode(monitor);

	if (descriptor instanceof JavaRefactoringDescriptor) {
		JavaRefactoringDescriptor javaDescriptor= (JavaRefactoringDescriptor) descriptor;
		RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(javaDescriptor.getID());

		Map<String, String> map= contribution.retrieveArgumentMap(descriptor);
		if (fJavaProject == null) {
			status.merge(RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.InitializableRefactoring_inacceptable_arguments));
			return null;
		}

		String name= fJavaProject.getElementName();

		String handle= map.get(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT);
		if (handle != null && handle.length() > 0)
			map.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT, getTransformedHandle(name, handle));

		int count= 1;
		String attribute= JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT + count;
		while ((handle= map.get(attribute)) != null) {
			if (handle.length() > 0)
				map.put(attribute, getTransformedHandle(name, handle));
			count++;
			attribute= JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT + count;
		}

		// create adapted descriptor
		try {
			descriptor= contribution.createDescriptor(descriptor.getID(), name, descriptor.getDescription(), descriptor.getComment(), map, descriptor.getFlags());
		} catch (IllegalArgumentException e) {
			status.merge(RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.InitializableRefactoring_inacceptable_arguments));
			return null;
		}
	}
	return descriptor.createRefactoringContext(status);
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Returns the refactoring contribution for the refactoring with the specified id.
 *
 * @param id the unique id of the refactoring
 * @return the refactoring contribution, or <code>null</code> if no refactoring contribution has
 *     been registered with the specified id
 */
public RefactoringContribution getRefactoringContribution(final String id) {
  Assert.isNotNull(id);
  Assert.isTrue(!"".equals(id)); // $NON-NLS-1$
  populateCache();
  return (RefactoringContribution) fContributionCache.get(id);
}
 

import org.eclipse.ltk.core.refactoring.RefactoringContribution; //导入依赖的package包/类
/**
 * Returns the refactoring id for the specified refactoring contribution.
 *
 * @param contribution the refactoring contribution
 * @return the corresonding refactoring id
 * @since 3.3
 */
public String getRefactoringId(final RefactoringContribution contribution) {
  Assert.isNotNull(contribution);
  populateCache();
  return (String) fIdCache.get(contribution);
}