import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status,
    RefactoringProcessor owner,
    String[] natures,
    SharableParticipants shared) {
  List<RefactoringParticipant> result = new ArrayList<RefactoringParticipant>();
  for (int i = 0; i < fRename.size(); i++) {
    result.addAll(
        Arrays.asList(
            ParticipantManager.loadRenameParticipants(
                status,
                owner,
                fRename.get(i),
                (RenameArguments) fRenameArguments.get(i),
                fParticipantDescriptorFilter.get(i),
                natures,
                shared)));
  }
  result.addAll(
      Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
  return result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status,
    RefactoringProcessor owner,
    String[] natures,
    SharableParticipants shared) {
  List<RefactoringParticipant> result = new ArrayList<RefactoringParticipant>();
  for (int i = 0; i < fMoves.size(); i++) {
    result.addAll(
        Arrays.asList(
            ParticipantManager.loadMoveParticipants(
                status,
                owner,
                fMoves.get(i),
                (MoveArguments) fMoveArguments.get(i),
                fParticipantDescriptorFilter.get(i),
                natures,
                shared)));
  }
  result.addAll(
      Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
  return result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status,
    RefactoringProcessor owner,
    String[] natures,
    SharableParticipants shared) {
  List<RefactoringParticipant> result = new ArrayList<RefactoringParticipant>();
  for (int i = 0; i < fCopies.size(); i++) {
    result.addAll(
        Arrays.asList(
            ParticipantManager.loadCopyParticipants(
                status,
                owner,
                fCopies.get(i),
                (CopyArguments) fCopyArguments.get(i),
                fParticipantDescriptorFilter.get(i),
                natures,
                shared)));
  }
  result.addAll(
      Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
  return result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
/**
 * Loads the change method signature participants for the given element.
 *
 * @param status a refactoring status to report status if problems occurred while loading the
 *     participants
 * @param processor the processor that will own the participants
 * @param method the method to be changed
 * @param arguments the change method signature arguments describing the change
 * @param filter a participant filter to exclude certain participants, or <code>null</code> if no
 *     filtering is desired
 * @param affectedNatures an array of project natures affected by the refactoring
 * @param shared a list of shared participants
 * @return an array of change method signature participants
 */
public static ChangeMethodSignatureParticipant[] loadChangeMethodSignatureParticipants(
    RefactoringStatus status,
    RefactoringProcessor processor,
    IMethod method,
    ChangeMethodSignatureArguments arguments,
    IParticipantDescriptorFilter filter,
    String[] affectedNatures,
    SharableParticipants shared) {
  RefactoringParticipant[] participants =
      fgMethodSignatureInstance.getParticipants(
          status, processor, method, arguments, filter, affectedNatures, shared);
  ChangeMethodSignatureParticipant[] result =
      new ChangeMethodSignatureParticipant[participants.length];
  System.arraycopy(participants, 0, result, 0, participants.length);
  return result;
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status, SharableParticipants sharedParticipants) throws CoreException {
  final ArrayList result = new ArrayList();
  if (!isApplicable()) {
    return new RefactoringParticipant[0];
  }

  final String[] affectedNatures = ResourceProcessors.computeAffectedNatures(fResources);
  final DeleteArguments deleteArguments = new DeleteArguments(fDeleteContents);
  for (int i = 0; i < fResources.length; i++) {
    result.addAll(
        Arrays.asList(
            ParticipantManager.loadDeleteParticipants(
                status,
                this,
                fResources[i],
                deleteArguments,
                affectedNatures,
                sharedParticipants)));
  }

  return (RefactoringParticipant[]) result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public void testCreateChange() {
  GWTRefactoringSupport support = new DummyGWTRefactoringSupport();
  support.setUpdateReferences(true);

  IType refactorTestType = refactorTestClass.getCompilationUnit().findPrimaryType();
  support.setOldElement(refactorTestType);

  RefactoringParticipant participant = new DummyRefactoringParticipant();
  IRefactoringChangeFactory changeFactory = new DefaultChangeFactory();
  CompositeChange change = support.createChange(participant, changeFactory);

  // Return value should contain one child change
  Change[] changeChildren = change.getChildren();
  assertEquals(1, changeChildren.length);

  // Root edit should contain two child edits, one for each JSNI ref
  TextChange childChange = (TextChange) changeChildren[0];
  TextEdit changeEdit = childChange.getEdit();
  assertEquals(2, changeEdit.getChildrenSize());
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public void testCreateChangeWithoutEdits() throws JavaModelException {
  GWTRefactoringSupport support = new DummyGWTRefactoringSupport();
  support.setUpdateReferences(true);

  IType entryPointType = getTestProject().findType(
      AbstractGWTPluginTestCase.TEST_PROJECT_SRC_PACKAGE,
      AbstractGWTPluginTestCase.TEST_PROJECT_ENTRY_POINT);
  support.setOldElement(entryPointType);

  // There are no references to the entry point class, so the Change returned
  // should be null
  RefactoringParticipant participant = new DummyRefactoringParticipant();
  IRefactoringChangeFactory changeFactory = new DefaultChangeFactory();
  CompositeChange change = support.createChange(participant, changeFactory);
  assertNull(change);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(RefactoringStatus status, SharableParticipants sharedParticipants)
		throws CoreException {
	RenameParticipant[] renameParticipants = ParticipantManager.loadRenameParticipants(status, this,
			renameElementContext, new RenameArguments(newName, true),
			new String[] { XtextProjectHelper.NATURE_ID }, sharedParticipants);
	return renameParticipants;
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status, SharableParticipants sharedParticipants) throws CoreException {
  String[] affectedNatures = JavaProcessors.computeAffectedNatures(fMethod);
  return JavaParticipantManager.loadChangeMethodSignatureParticipants(
      status,
      this,
      fMethod,
      getParticipantArguments(),
      null,
      affectedNatures,
      sharedParticipants);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public final RefactoringParticipant[] loadParticipants(
    RefactoringStatus status,
    RefactoringProcessor processor,
    String[] natures,
    SharableParticipants shared)
    throws CoreException {
  RefactoringModifications modifications = getModifications();
  if (modifications != null) {
    return modifications.loadParticipants(status, processor, natures, shared);
  } else {
    return new RefactoringParticipant[0];
  }
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public RefactoringParticipant[] loadParticipants(
    RefactoringStatus status, SharableParticipants shared) throws CoreException {
  String[] affectedNatures = ResourceProcessors.computeAffectedNatures(fResourcesToMove);

  List result = new ArrayList();
  for (int i = 0; i < fResourcesToMove.length; i++) {
    MoveParticipant[] participants =
        ParticipantManager.loadMoveParticipants(
            status, this, fResourcesToMove[i], fMoveArguments, null, affectedNatures, shared);
    result.addAll(Arrays.asList(participants));
  }
  return (RefactoringParticipant[]) result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public RefactoringParticipant createParticipant() throws CoreException {
  //		return (RefactoringParticipant)fConfigurationElement.createExecutableExtension(CLASS);
  if (participant != null) {
    try {
      return participant.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
      e.printStackTrace();
      return null;
    }
  } else {
    return null;
  }
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public static Set<Class<? extends RefactoringParticipant>> getParticipantsFor(String id) {
  Set<Class<? extends RefactoringParticipant>> classes = registry.get(id);
  if (classes == null) {
    classes = new HashSet<>(0);
  }
  return classes;
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public void testCreateChangeWithoutUpdateReferences() {
  GWTRefactoringSupport support = new DummyGWTRefactoringSupport();
  support.setUpdateReferences(false);

  // With update references turned off, Change returned should be null
  RefactoringParticipant participant = new DummyRefactoringParticipant();
  IRefactoringChangeFactory changeFactory = new DefaultChangeFactory();
  Change change = support.createChange(participant, changeFactory);
  assertNull(change);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
/**
 * Attempts to merge all the text changes rooted at <code>rootChange</code>
 * into the refactoring's shared text change for each file (via
 * {@link RefactoringParticipant#getTextChange(Object)}). Any text changes
 * that are merged will be removed from their parents.
 * 
 * 
 * @param participant the participant which will be used to get the shared
 *          text change for each file
 * @param rootChange the root of the change tree that will be searched for
 *          text changes to merge into the shared text changes
 * @return true if the entire tree was merged and the root change is no longer
 *         valid
 */
public static boolean mergeParticipantTextChanges(
    final RefactoringParticipant participant, Change rootChange) {
  final List<Change> dupChanges = new ArrayList<Change>();
  ChangeUtilities.acceptOnChange(rootChange, new ChangeVisitor() {
    public void visit(Change change) {
      if (change instanceof TextEditBasedChange) {
        TextEditBasedChange textChange = (TextEditBasedChange) change;
        TextChange existingTextChange = participant.getTextChange(textChange.getModifiedElement());
        if (existingTextChange == null) {
          return;
        }

        // Merge all changes from text change into the existing
        TextEditUtilities.moveTextEditGroupsIntoChange(
            textChange.getChangeGroups(), existingTextChange);

        dupChanges.add(textChange);
      }
    }
  });

  for (Change dupChange : dupChanges) {
    ChangeUtilities.removeChange(dupChange,
        (CompositeChange) dupChange.getParent());
  }

  return dupChanges.contains(rootChange);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public RefactoringParticipant[] loadParticipants(RefactoringStatus status,
        SharableParticipants shared) throws CoreException {
    // TODO: figure out participants to return here
    return new RefactoringParticipant[0];

    // String[] affectedNatures=
    // ResourceProcessors.computeAffectedNatures(fResource);
    // return ParticipantManager.loadRenameParticipants(status, this,
    // fResource, fRenameArguments, null, affectedNatures, shared);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
public RefactoringParticipant[] loadParticipants(RefactoringStatus status, SharableParticipants shared) throws CoreException {
		// TODO: figure out participants to return here
		return new RefactoringParticipant[0];
		
//		String[] affectedNatures= ResourceProcessors.computeAffectedNatures(fResource);
//		return ParticipantManager.loadRenameParticipants(status, this, fResource, fRenameArguments, null, affectedNatures, shared);
	}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public RefactoringParticipant[] loadParticipants(RefactoringStatus status, SharableParticipants sharedParticipants) throws CoreException {
	List<MoveParticipant> result= new ArrayList<MoveParticipant>();
	MoveArguments args= new MoveArguments(fDestinationType, true);
	String[] natures= JavaProcessors.computeAffectedNaturs(fMembersToMove);
	for (int i= 0; i < fMembersToMove.length; i++) {
		IMember member= fMembersToMove[i];
		result.addAll(Arrays.asList(ParticipantManager.loadMoveParticipants(
			status, this, member, args, natures, sharedParticipants)));
	}
	return result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(RefactoringStatus status, RefactoringProcessor owner, String[] natures, SharableParticipants shared) {
	List<RefactoringParticipant> result= new ArrayList<RefactoringParticipant>();
	for (int i= 0; i < fRename.size(); i++) {
		result.addAll(Arrays.asList(ParticipantManager.loadRenameParticipants(status,
			owner, fRename.get(i),
			(RenameArguments) fRenameArguments.get(i),
			fParticipantDescriptorFilter.get(i),
			natures, shared)));
	}
	result.addAll(Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
	return result.toArray(new RefactoringParticipant[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant; //导入依赖的package包/类
@Override
public RefactoringParticipant[] loadParticipants(RefactoringStatus status, RefactoringProcessor owner, String[] natures, SharableParticipants shared) {
	List<RefactoringParticipant> result= new ArrayList<RefactoringParticipant>();
	for (Iterator<IJavaElement> iter= fDelete.iterator(); iter.hasNext();) {
		result.addAll(Arrays.asList(ParticipantManager.loadDeleteParticipants(status,
			owner, iter.next(),
			new DeleteArguments(), natures, shared)));
	}
	result.addAll(Arrays.asList(getResourceModifications().getParticipants(status, owner, natures, shared)));
	return result.toArray(new RefactoringParticipant[result.size()]);
}