Java TextEditBasedChange类代码示例

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
public ChangePreview feedInput(IChangePreviewViewer viewer, List categories)
    throws CoreException {
  InternalTextEditChangeNode element = getTextEditChangeNode();
  if (element != null) {
    Change change = element.getChange();
    if (change instanceof TextEditBasedChange) {
      List groups = collectTextEditBasedChangeGroups(categories);
      return viewer.setInput(
          TextEditChangePreviewViewer.createInput(
              change,
              (TextEditBasedChangeGroup[])
                  groups.toArray(new TextEditBasedChangeGroup[groups.size()]),
              getTextRange()));
    }
  } else {
    return viewer.setInput(null);
  }
  return null;
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
public ChangePreview feedInput(IChangePreviewViewer viewer, List categories)
    throws CoreException {
  InternalTextEditChangeNode element = getTextEditChangeNode();
  if (element != null) {
    Change change = element.getChange();
    if (change instanceof TextEditBasedChange) {
      IRegion range = getTextRange(this);
      ChangePreviewViewerInput input = null;
      if (range != null) {
        input =
            TextEditChangePreviewViewer.createInput(
                change, new TextEditBasedChangeGroup[] {fChangeGroup}, range);
      } else {
        input = TextEditChangePreviewViewer.createInput(change, fChangeGroup, 2);
      }
      return viewer.setInput(input);
    }
  } else {
    return viewer.setInput(null);
  }
  return null;
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
/**
 * Returns all text changes managed by this instance.
 *
 * @return all text changes managed by this instance
 */
public TextEditBasedChange[] getAllChanges(){
	Set<ICompilationUnit> cuSet= fMap.keySet();
	ICompilationUnit[] cus= cuSet.toArray(new ICompilationUnit[cuSet.size()]);
	// sort by cu name:
	Arrays.sort(cus, new Comparator<ICompilationUnit>() {
		public int compare(ICompilationUnit o1, ICompilationUnit o2) {
			String name1= o1.getElementName();
			String name2= o2.getElementName();
			return name1.compareTo(name2);
		}
	});

	TextEditBasedChange[] textChanges= new TextEditBasedChange[cus.length];
	for (int i= 0; i < cus.length; i++) {
		textChanges[i]= fMap.get(cus[i]);
	}
	return textChanges;
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
public static Change wrap(Change delegate) {
	if(delegate instanceof TextEditBasedChange) {
		return new TextEditBased((TextEditBasedChange) delegate);
	} else {
		return new Generic(delegate);
	}
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
protected ChildNode[] createChildNodes() {
  TextEditBasedChange change = getTextEditBasedChange();
  if (change instanceof MultiStateTextFileChange) {
    return new ChildNode
        [0]; // no edit preview & edit disabling possible in the MultiStateTextFileChange (edits
    // must be applied in sequence)
  }
  TextEditBasedChangeGroup[] groups = getSortedChangeGroups(change);
  ChildNode[] result = new ChildNode[groups.length];
  for (int i = 0; i < groups.length; i++) {
    result[i] = new TextEditGroupNode(this, groups[i]);
  }
  return result;
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
private TextEditBasedChangeGroup[] getSortedChangeGroups(TextEditBasedChange change) {
  TextEditBasedChangeGroup[] groups = change.getChangeGroups();
  List result = new ArrayList(groups.length);
  for (int i = 0; i < groups.length; i++) {
    if (!groups[i].getTextEditGroup().isEmpty()) result.add(groups[i]);
  }
  Comparator comparator = new OffsetComparator();
  Collections.sort(result, comparator);
  return (TextEditBasedChangeGroup[]) result.toArray(new TextEditBasedChangeGroup[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
@Override
protected ChildNode[] createChildNodes() {
  TextEditBasedChange change = getTextEditBasedChange();
  if (change instanceof MultiStateTextFileChange) {
    return new ChildNode
        [0]; // no edit preview & edit disabling possible in the MultiStateTextFileChange (edits
    // must be applied
    // in sequence)
  }

  ICompilationUnit cunit = (ICompilationUnit) change.getAdapter(ICompilationUnit.class);
  if (cunit != null) {
    List<ChildNode> children = new ArrayList<ChildNode>(5);
    Map<IJavaElement, JavaLanguageNode> map = new HashMap<IJavaElement, JavaLanguageNode>(20);
    TextEditBasedChangeGroup[] changes = getSortedChangeGroups(change);
    for (int i = 0; i < changes.length; i++) {
      TextEditBasedChangeGroup tec = changes[i];
      try {
        IJavaElement element = getModifiedJavaElement(tec, cunit);
        if (element.equals(cunit)) {
          children.add(createTextEditGroupNode(this, tec));
        } else {
          JavaLanguageNode pjce = getChangeElement(map, element, children, this);
          pjce.addChild(createTextEditGroupNode(pjce, tec));
        }
      } catch (JavaModelException e) {
        children.add(createTextEditGroupNode(this, tec));
      }
    }
    return children.toArray(new ChildNode[children.size()]);
  } else {
    return EMPTY_CHILDREN;
  }
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
private TextEditBasedChangeGroup[] getSortedChangeGroups(TextEditBasedChange change) {
  TextEditBasedChangeGroup[] edits = change.getChangeGroups();
  List<TextEditBasedChangeGroup> result = new ArrayList<TextEditBasedChangeGroup>(edits.length);
  for (int i = 0; i < edits.length; i++) {
    if (!edits[i].getTextEditGroup().isEmpty()) result.add(edits[i]);
  }
  Comparator<TextEditBasedChangeGroup> comparator = new OffsetComparator();
  Collections.sort(result, comparator);
  return result.toArray(new TextEditBasedChangeGroup[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
public static ChangePreviewViewerDescriptor get(Object element) throws CoreException {
  if (element instanceof TextEditBasedChange) {
    return changePreviewViewerDescriptor;
  }
  return null;
  //        return fgDescriptions.get(element.getClass());
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的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.TextEditBasedChange; //导入依赖的package包/类
/**
 * Finds the text edit group which has the given text edit as a child.
 * 
 * @param change the change that contains the groups
 * @param edit the text edit to find
 * @return the group that has the text edit as a child, or null
 */
public static TextEditGroup findTextEditGroup(TextEditBasedChange change, TextEdit edit) {
  for (TextEditGroup group : getTextEditGroups(change.getChangeGroups())) {
    for (TextEdit curEdit : group.getTextEdits()) {
      if (edit == curEdit) {
        return group;
      }
    }
  }

  return null;
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
@Override
protected ChildNode[] createChildNodes() {
	TextEditBasedChange change= getTextEditBasedChange();
	if (change instanceof MultiStateTextFileChange) {
		return new ChildNode[0]; // no edit preview & edit disabling possible in the MultiStateTextFileChange (edits must be applied in sequence)
	}

	ICompilationUnit cunit= (ICompilationUnit) change.getAdapter(ICompilationUnit.class);
	if (cunit != null) {
		List<ChildNode> children= new ArrayList<ChildNode>(5);
		Map<IJavaElement, JavaLanguageNode> map= new HashMap<IJavaElement, JavaLanguageNode>(20);
		TextEditBasedChangeGroup[] changes= getSortedChangeGroups(change);
		for (int i= 0; i < changes.length; i++) {
			TextEditBasedChangeGroup tec= changes[i];
			try {
				IJavaElement element= getModifiedJavaElement(tec, cunit);
				if (element.equals(cunit)) {
					children.add(createTextEditGroupNode(this, tec));
				} else {
					JavaLanguageNode pjce= getChangeElement(map, element, children, this);
					pjce.addChild(createTextEditGroupNode(pjce, tec));
				}
			} catch (JavaModelException e) {
				children.add(createTextEditGroupNode(this, tec));
			}
		}
		return children.toArray(new ChildNode[children.size()]);
	} else {
		return EMPTY_CHILDREN;
	}
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
private TextEditBasedChangeGroup[] getSortedChangeGroups(TextEditBasedChange change) {
	TextEditBasedChangeGroup[] edits= change.getChangeGroups();
	List<TextEditBasedChangeGroup> result= new ArrayList<TextEditBasedChangeGroup>(edits.length);
	for (int i= 0; i < edits.length; i++) {
		if (!edits[i].getTextEditGroup().isEmpty())
			result.add(edits[i]);
	}
	Comparator<TextEditBasedChangeGroup> comparator= new OffsetComparator();
	Collections.sort(result, comparator);
	return result.toArray(new TextEditBasedChangeGroup[result.size()]);
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
public Object getAdapter(Object object, Class key) {
	if (!TextEditChangeNode.class.equals(key))
		return null;
	if (!(object instanceof CompilationUnitChange) && !(object instanceof MultiStateCompilationUnitChange))
		return null;
	return new CompilationUnitChangeNode((TextEditBasedChange)object);
}
 

import org.eclipse.ltk.core.refactoring.TextEditBasedChange; //导入依赖的package包/类
protected TextEditBased(TextEditBasedChange delegate) {
	super(delegate.getName());
	this.delegate = delegate;
}