import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
/**
 * Prepares the rename.
 *
 * @param refactoringElementsBag
 * @param folder the folder or package to be renamed.
 * @param oldName the old FQN of the folder / package.
 * @param newName the new FQN of the folder / package.
 */
private Problem doPrepare(RefactoringElementsBag refactoringElementsBag, FileObject folder, String oldName, String newName){
    Problem result = null;
    
    for (FileObject each : getPersistenceXmls(folder)){
        try {
            PUDataObject pUDataObject = ProviderUtil.getPUDataObject(each);
            for (String clazz : getClasses(folder, new ArrayList<String>())){
                List<PersistenceUnit> punits = getAffectedPersistenceUnits(pUDataObject, clazz);
                String newClassName = clazz.replace(oldName, newName);
                for (PersistenceUnit persistenceUnit : punits) {
                    refactoringElementsBag.add(getRefactoring(),
                            new PersistenceXmlPackageRenameRefactoringElement(persistenceUnit, clazz, newClassName, pUDataObject, each));
                }
            }
        } catch (InvalidPersistenceXmlException ex) {
            Problem newProblem =
                    new Problem(false, NbBundle.getMessage(PersistenceXmlRefactoring.class, "TXT_PersistenceXmlInvalidProblem", ex.getPath()));
            
            result = RefactoringUtil.addToEnd(newProblem, result);
        }
    }
    return result;
    
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag refactoringElementsBag) {

    MetadataModel<EntityMappingsMetadata> emModel = getEntityMappingsModel();
    if (emModel == null) {
        return null;
    }

    EntityAssociationResolver resolver = new EntityAssociationResolver(treePathHandle, emModel);
    try {
        List<EntityAnnotationReference> references = resolver.resolveReferences();
        for (EntityAnnotationReference ref : references) {
            EntityRenameElement element = new EntityRenameElement(ref, rename);
            refactoringElementsBag.add(rename, element);
        }
    } catch (IOException ioe) {
        Exceptions.printStackTrace(ioe);
    }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
private Problem preparePackageDelete(NonRecursiveFolder folder, RefactoringElementsBag refactoringElements) {
    DataFolder dataFolder = DataFolder.findFolder(folder.getFolder());
    // First; delete all files except packages
    DataObject children[] = dataFolder.getChildren();
    boolean empty = true;
    for( int i = 0; children != null && i < children.length; i++ ) {
        FileObject fileObject = children[i].getPrimaryFile();
        if ( !fileObject.isFolder() ) {
            refactoringElements.addFileChange(refactoring, new DeleteFile(fileObject, refactoringElements));
        }
        else {
            empty = false;
        }
    }

    // If empty delete itself
    if ( empty ) {
        refactoringElements.addFileChange(refactoring, new PackageDeleteElem(folder));
    }
        
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override public RefactoringPlugin createInstance(AbstractRefactoring refactoring) {
    return new RefactoringPlugin() {
        @Override public Problem preCheck() { return null; }
        @Override
        public Problem checkParameters() { return null; }

        @Override
        public Problem fastCheckParameters() { return null; }

        @Override
        public void cancelRequest() { endTransaction(); }

        @Override
        public Problem prepare(RefactoringElementsBag refactoringElements) {
            beginTransaction();
            return null;
        }
    };
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected final Problem checkMethodLayer(InfoHolder info, FileObject fo, RefactoringElementsBag refactoringElements) {
    Problem problem = null;
    // do our check just on static methods
    // #167439: o.n.core.startup.layers.BinaryFS explicitly allows for private methods
    if (!info.isStatic) {
        return problem;
    }
    // with no parameters or with parameter of type FileObject
    if (!info.hasFileObjectParam && !info.hasNoParams) {
        return problem;
    }
    Project project = FileOwnerQuery.getOwner(fo);
    if (project != null) {
        LayerHandle handle = LayerHandle.forProject(project);
        FileSystem fs = handle.layer(false);
        if (fs != null) {
            checkFileObject(fs.getRoot(), info.name, null, info.fullName, refactoringElements, handle);
        }
    }
    return problem;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected final Problem checkConstructorLayer(InfoHolder info, FileObject fo, RefactoringElementsBag refactoringElements) {
    Problem problem = null;
    // just consider public constructors with no params..
    if (!info.isPublic || !info.hasNoParams) {
        return problem;
    }
    Project project = FileOwnerQuery.getOwner(fo);
    if (project != null) {
        LayerHandle handle = LayerHandle.forProject(project);
        FileSystem fs = handle.layer(false);
        if (fs != null) {
            checkFileObject(fs.getRoot(), null, info.name, info.fullName, refactoringElements, handle);
        }
    }
    return problem;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected final Problem createAndAddElements(Set<FileObject> files, CancellableTask<WorkingCopy> task, RefactoringElementsBag elements, AbstractRefactoring refactoring, ClasspathInfo info) {
    try {
        final Collection<ModificationResult> results = processFiles(files, task, info);
        elements.registerTransaction(createTransaction(results));
        for (ModificationResult result:results) {
            for (FileObject jfo : result.getModifiedFileObjects()) {
                for (Difference dif: result.getDifferences(jfo)) {
                        elements.add(refactoring,DiffElement.create(dif, jfo, result));
                }
            }
        }
    } catch (IOException e) {
        return createProblemAndLog(null, e);
    }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag reb) {
    if (!isRenameTestClass() && !isRenameTestClassMethod()) {
        return null;
    }
    initDelegates();
    fireProgressListenerStart(ProgressEvent.START, renameDelegates.length);
    Problem p = null;
    for (RenameRefactoring delegate : renameDelegates) {
        p = JavaPluginUtils.chainProblems(p, delegate.prepare(reb.getSession()));
        if (p != null && p.isFatal()) {
            return p;
        }
        fireProgressListenerStep();
    }
    fireProgressListenerStop();
    return p;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
public Problem prepare(RefactoringElementsBag refactoringElements) {
    cancel.set(false);

    //Collection<MessageImpl> problems = refactoring.isQuery() ? performSearchForPattern(refactoringElements) : performApplyPattern(refactoringElements);
    
    Collection<MessageImpl> problems = performSearchForPattern(refactoringElements);
    problems.addAll(performApplyPattern(refactoringElements));
    
    Problem current = null;

    for (MessageImpl problem : problems) {
        Problem p = new Problem(problem.kind == MessageKind.ERROR, problem.text);

        if (current != null)
            p.setNext(current);
        current = p;
    }

    return current;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Messages("WARN_HasQueries=The selected configuration contains inspections that do not provide any transformations. " +
          "No diff will be provided for code detected by such inspections. Use Source/Inspect... to perform code analysis.")
private List<MessageImpl> performSearchForPattern(final RefactoringElementsBag refactoringElements) {
    ProgressHandleWrapper w = new ProgressHandleWrapper(this, 10, 90);
    Iterable<? extends HintDescription> queries = filterQueries(refactoring.getPattern(), true);
    BatchResult candidates = BatchSearch.findOccurrences(queries, refactoring.getScope(), w, /*XXX:*/HintsSettings.getGlobalSettings());
    List<MessageImpl> problems = new LinkedList<MessageImpl>(candidates.problems);

    if (queries.iterator().hasNext()) {
        problems.add(new MessageImpl(MessageKind.WARNING, Bundle.WARN_HasQueries()));
    }
    
    prepareElements(candidates, w, refactoringElements, refactoring.isVerify(), problems);

    w.finish();

    return problems;
 }
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare( RefactoringElementsBag bag ) {
    Project project = getProject();

    GwtModuleAcceptor acceptor = getAcceptor();
    Set<FileObject> files = getAffectedJavaFiles(project, acceptor);
    Set<FileObject> additionalFiles =
            getAffectedConfigFiles(project, acceptor);
    fireProgressListenerStart(AbstractRefactoring.PREPARE, files.size()
            + additionalFiles.size());
    Problem problem =
            createAndAddElements(files, getTransformTask(), bag,
                    getRefactoring());
    Problem configProblem =
            createAndAddConfigElements(additionalFiles, bag);
    fireProgressListenerStop();
    if (problem != null) {
        problem.setNext(configProblem);
        return problem;
    }
    else {
        return configProblem;
    }
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected Problem setWidgetsetAddon( RefactoringElementsBag bag ) {
    Project project = getProject();
    VaadinSupport support = project.getLookup().lookup(VaadinSupport.class);
    if (support == null || support.isWeb()) {
        return null;
    }
    List<String> widgetsets = support.getAddonWidgetsets();
    if (widgetsets == null || widgetsets.size() != 1) {
        return null;
    }
    if (getAcceptor().accept(widgetsets.get(0))) {
        return bag.add(
                getRefactoring(),
                new AddOnRefactoringElementImplementation(support, support
                        .getAddonWidgetsets(), null));
    }
    else {
        return null;
    }
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected Problem setWidgetsetAddon( RefactoringElementsBag bag ) {
    Project project = getTargetProject();
    VaadinSupport support = project.getLookup().lookup(VaadinSupport.class);
    if (support == null || support.isWeb()) {
        return null;
    }
    List<String> widgetsets = support.getAddonWidgetsets();
    if (!project.equals(getProject())) {
        if (widgetsets == null || widgetsets.size() == 0) {
            return bag.add(getRefactoring(),
                    new AddOnRefactoringElementImplementation(support,
                            null, getTargetWidgetset()));
        }
    }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
protected Problem setWidgetsetAddon( RefactoringElementsBag bag ) {
    Project project = getProject();
    VaadinSupport support = project.getLookup().lookup(VaadinSupport.class);
    if (support == null || support.isWeb()) {
        return null;
    }
    String targetWidgetset = getTargetWidgetset(support);
    if (targetWidgetset == null) {
        return null;
    }
    else {
        return bag.add(
                getRefactoring(),
                new AddOnRefactoringElementImplementation(support, support
                        .getAddonWidgetsets(), targetWidgetset));
    }
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
protected Problem setWidgetsetAddon( RefactoringElementsBag bag ) {
    Project project = getTargetProject();
    VaadinSupport support = project.getLookup().lookup(VaadinSupport.class);
    if (support == null || support.isWeb()) {
        return null;
    }
    List<String> widgetsets = support.getAddonWidgetsets();
    if (widgetsets != null && project.equals(getProject())
            && widgetsets.size() == 1
            && getAcceptor().accept(widgetsets.get(0)))
    {
        return bag.add(getRefactoring(),
                new AddOnRefactoringElementImplementation(support,
                        widgetsets, getTargetWidgetset()));
    }
    else {
        return super.setWidgetsetAddon(bag);
    }
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag refactoringElementsBag) {
    if (isPackage()){
        FileObject pkg = renameRefactoring.getRefactoringSource().lookup(NonRecursiveFolder.class).getFolder();
        String oldPackageName = JavaIdentifiers.getQualifiedName(pkg);
        
        return doPrepare(refactoringElementsBag, pkg, oldPackageName, renameRefactoring.getNewName());
    } else if (isFolder()){
        FileObject folder = renameRefactoring.getRefactoringSource().lookup(FileObject.class);
        ClassPath classPath = ClassPath.getClassPath(folder, ClassPath.SOURCE);
        if(classPath == null){
            return null;//it may happens for folders in php and similar projects, see #181611
        }
        FileObject root = classPath.findOwnerRoot(folder);
        // issue 62320. By JavaDoc, ClassPath.fineOwnerRoot can return null
        if(root == null ) {
            return null;
        }
        String prefix = FileUtil.getRelativePath(root, folder.getParent());
        // #249491
        if (prefix == null) {
            return null;
        }
        prefix = prefix.replace('/','.'); // NOI18N
        String oldName = buildName(prefix, folder.getName());
        // the new package name
        String newName = buildName(prefix, renameRefactoring.getNewName());
        
        return doPrepare(refactoringElementsBag, folder, oldName, newName);
    }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag refactoringElementsBag) {
    
    if (!shouldHandle()){
        return null;
    }
    
    Problem result = null;
    for (FileObject refactoringSource : getRefactoringSources()) {
        Project project = FileOwnerQuery.getOwner(refactoringSource);
        if (project == null) {
            continue;
        }
        if (!shouldHandle(refactoringSource)){
            continue;
        }
        String classNameFQN = JavaIdentifiers.getQualifiedName(refactoringSource);

        for (FileObject each : getPersistenceXmls(refactoringSource)){
            try {
                PUDataObject pUDataObject = ProviderUtil.getPUDataObject(each);
                List<PersistenceUnit> punits = getAffectedPersistenceUnits(pUDataObject, classNameFQN);
                for (PersistenceUnit persistenceUnit : punits) {
                    refactoringElementsBag.add(getRefactoring(), getRefactoringElement(persistenceUnit, refactoringSource, pUDataObject, each));
                }
            } catch (InvalidPersistenceXmlException ex) {
                Problem newProblem =
                        new Problem(false, NbBundle.getMessage(PersistenceXmlRefactoring.class, "TXT_PersistenceXmlInvalidProblem", ex.getPath()));

                result = RefactoringUtil.addToEnd(newProblem, result);
            }
        }
    }
    
    return result;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag elements) {
    for (FileObject fo: refactoring.getRefactoringSource().lookupAll(FileObject.class)) {
            elements.addFileChange(refactoring, new DeleteFile(fo, elements));
        }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag elements) {
    URL targetUrl = ((MoveRefactoring) refactoring).getTarget().lookup(URL.class);        
    if(targetUrl != null) {
        for (FileObject o: refactoring.getRefactoringSource().lookupAll(FileObject.class)) {
            elements.addFileChange(refactoring, new MoveFile(o, elements));
        }
    }
    return null;
}
 

import org.netbeans.modules.refactoring.spi.RefactoringElementsBag; //导入依赖的package包/类
@Override
public Problem prepare(RefactoringElementsBag refactoringElements) {
    Lookup lkp = refactoring.getRefactoringSource();
    NonRecursiveFolder folder = lkp.lookup(NonRecursiveFolder.class);
    if (folder != null) {
        return preparePackageDelete(folder, refactoringElements);
    }
    
    FileObject fileObject = lkp.lookup(FileObject.class);
    if (fileObject != null && fileObject.isFolder()) {
        return prepareFolderDelete(fileObject, refactoringElements);
    }
    return null;
}