private static boolean containsConflictingClass(String fqName, PsiJavaFile file) {
final PsiClass[] classes = file.getClasses();
for (PsiClass aClass : classes) {
if (containsConflictingInnerClass(fqName, aClass)) {
return true;
}
}
return false;
}
private static boolean containsConflictingClassName(String fqName, PsiJavaFile file) {
final int lastDotIndex = fqName.lastIndexOf((int) '.');
final String shortName = fqName.substring(lastDotIndex + 1);
final PsiClass[] classes = file.getClasses();
for (PsiClass aClass : classes) {
if (shortName.equals(aClass.getName())) {
return true;
}
}
return false;
}
@NotNull
private File fileToFile(PsiJavaFile javaFile, List<String> additionalImports) {
PsiImportList importList = javaFile.getImportList();
List<Import> imports =
importList == null
? Collections.<Import>emptyList()
: importsToImportList(importList.getAllImportStatements());
for (String i : additionalImports) imports.add(new Import(i));
return new File(
quoteKeywords(javaFile.getPackageName()),
imports,
classesToClassList(javaFile.getClasses()),
createMainFunction(javaFile));
}
private static PsiClass findSingleImportByShortName(
@NotNull PsiJavaFile file, @NotNull String shortClassName) {
PsiClass[] refs = file.getSingleClassImports(true);
for (PsiClass ref : refs) {
String className = ref.getQualifiedName();
if (className != null && PsiNameHelper.getShortClassName(className).equals(shortClassName)) {
return ref;
}
}
for (PsiClass aClass : file.getClasses()) {
String className = aClass.getQualifiedName();
if (className != null && PsiNameHelper.getShortClassName(className).equals(shortClassName)) {
return aClass;
}
}
return null;
}
public static boolean isInside(PsiElement place, PsiElement ancestor) {
if (SafeDeleteProcessor.isInside(place, ancestor)) return true;
if (PsiTreeUtil.getParentOfType(place, PsiComment.class, false) != null
&& ancestor instanceof PsiClass) {
final PsiClass aClass = (PsiClass) ancestor;
if (aClass.getParent() instanceof PsiJavaFile) {
final PsiJavaFile file = (PsiJavaFile) aClass.getParent();
if (PsiTreeUtil.isAncestor(file, place, false)) {
if (file.getClasses().length == 1) { // file will be deleted on class deletion
return true;
}
}
}
}
return false;
}
private PsiClass buildClass() {
final PsiManager manager = sourceClass.getManager();
final Project project = sourceClass.getProject();
final ExtractedClassBuilder extractedClassBuilder = new ExtractedClassBuilder();
extractedClassBuilder.setProject(myProject);
extractedClassBuilder.setClassName(newClassName);
extractedClassBuilder.setPackageName(newPackageName);
extractedClassBuilder.setOriginalClassName(sourceClass.getQualifiedName());
extractedClassBuilder.setRequiresBackPointer(requiresBackpointer);
extractedClassBuilder.setExtractAsEnum(enumConstants);
for (PsiField field : fields) {
extractedClassBuilder.addField(field);
}
for (PsiMethod method : methods) {
extractedClassBuilder.addMethod(method);
}
for (PsiClass innerClass : innerClasses) {
extractedClassBuilder.addInnerClass(
innerClass, innerClassesToMakePublic.contains(innerClass));
}
extractedClassBuilder.setTypeArguments(typeParams);
final List<PsiClass> interfaces = calculateInterfacesSupported();
extractedClassBuilder.setInterfaces(interfaces);
if (myGenerateAccessors) {
final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass();
sourceClass.accept(visitor);
extractedClassBuilder.setFieldsNeedingGetters(visitor.getFieldsNeedingGetter());
extractedClassBuilder.setFieldsNeedingSetters(visitor.getFieldsNeedingSetter());
}
final String classString = extractedClassBuilder.buildBeanClass();
if (extractInnerClass) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiJavaFile newFile =
(PsiJavaFile)
factory.createFileFromText(
newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiClass psiClass = newFile.getClasses()[0];
if (!psiClass.isEnum()) {
final PsiModifierList modifierList = psiClass.getModifierList();
assert modifierList != null;
modifierList.setModifierProperty(PsiModifier.STATIC, true);
}
final PsiElement addedClass = sourceClass.add(psiClass);
return (PsiClass)
CodeStyleManager.getInstance(manager)
.reformat(
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedClass));
}
try {
final PsiFile containingFile = sourceClass.getContainingFile();
final PsiDirectory directory;
final PsiDirectory containingDirectory = containingFile.getContainingDirectory();
if (myMoveDestination != null) {
directory = myMoveDestination.getTargetDirectory(containingDirectory);
} else {
final Module module = ModuleUtil.findModuleForPsiElement(containingFile);
assert module != null;
directory =
PackageUtil.findOrCreateDirectoryForPackage(
module, newPackageName, containingDirectory, false, true);
}
if (directory != null) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiFile newFile =
factory.createFileFromText(newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiElement addedFile = directory.add(newFile);
final CodeStyleManager codeStyleManager =
CodeStyleManager.getInstance(manager.getProject());
final PsiElement shortenedFile =
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedFile);
return ((PsiJavaFile) codeStyleManager.reformat(shortenedFile)).getClasses()[0];
} else {
return null;
}
} catch (IncorrectOperationException e) {
return null;
}
}
