private static PsiClass createClassFromTemplate(
@NotNull PsiDirectory dir, String name, String templateName, boolean askToDefineVariables)
throws IncorrectOperationException {
// checkCreateClassOrInterface(dir, name);
FileTemplate template = FileTemplateManager.getInstance().getInternalTemplate(templateName);
Properties defaultProperties = FileTemplateManager.getInstance().getDefaultProperties();
Properties properties = new Properties(defaultProperties);
properties.setProperty(FileTemplate.ATTRIBUTE_NAME, name);
String ext = StdFileTypes.JAVA.getDefaultExtension();
String fileName = name + "." + ext;
PsiElement element;
try {
element =
askToDefineVariables
? new CreateFromTemplateDialog(dir.getProject(), dir, template, null, properties)
.create()
: FileTemplateUtil.createFromTemplate(template, fileName, properties, dir);
} catch (IncorrectOperationException e) {
throw e;
} catch (Exception e) {
LOG.error(e);
return null;
}
if (element == null) return null;
final PsiJavaFile file = (PsiJavaFile) element.getContainingFile();
PsiClass[] classes = file.getClasses();
if (classes.length < 1) {
throw new IncorrectOperationException(getIncorrectTemplateMessage(templateName));
}
return classes[0];
}
private boolean isActionAvailable(AnActionEvent e) {
final VirtualFile file = getVirtualFiles(e);
if (getEventProject(e) != null && file != null) {
final FileType fileType = file.getFileType();
if (StdFileTypes.JAVA.equals(fileType)) {
return true;
}
}
return false;
}
public JavaCallerChooser(
PsiMethod method,
Project project,
String title,
Tree previousTree,
Consumer<Set<PsiMethod>> callback) {
super(
method,
project,
title,
previousTree,
"dummy." + StdFileTypes.JAVA.getDefaultExtension(),
callback);
}
public static void checkCreateClassOrInterface(@NotNull PsiDirectory directory, String name)
throws IncorrectOperationException {
PsiUtil.checkIsIdentifier(directory.getManager(), name);
String fileName = name + "." + StdFileTypes.JAVA.getDefaultExtension();
directory.checkCreateFile(fileName);
PsiNameHelper helper = JavaPsiFacade.getInstance(directory.getProject()).getNameHelper();
PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(directory);
String qualifiedName = aPackage == null ? null : aPackage.getQualifiedName();
if (!StringUtil.isEmpty(qualifiedName) && !helper.isQualifiedName(qualifiedName)) {
throw new IncorrectOperationException(
"Cannot create class in invalid package: '" + qualifiedName + "'");
}
}
protected JavaStubElementType(@NotNull @NonNls final String debugName) {
super(debugName, StdFileTypes.JAVA != null ? StdFileTypes.JAVA.getLanguage() : null);
}
public PsiImportList prepareOptimizeImportsResult(@NotNull final PsiJavaFile file) {
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(file.getProject());
final Set<String> namesToImportStaticly = new THashSet<String>();
String[] names =
collectNamesToImport(
file,
namesToImportStaticly); // Note: this array may contain "<packageOrClassName>.*" for
// unresolved imports!
Arrays.sort(names);
ArrayList<String> namesList = new ArrayList<String>();
ImportLayoutTable table = mySettings.IMPORT_LAYOUT_TABLE;
if (table != null) {
int[] entriesForName = ArrayUtil.newIntArray(names.length);
for (int i = 0; i < names.length; i++) {
entriesForName[i] = findEntryIndex(names[i]);
}
Entry[] entries = table.getEntries();
for (int i = 0; i < entries.length; i++) {
Entry entry = entries[i];
if (entry instanceof PackageEntry) {
for (int j = 0; j < names.length; j++) {
if (entriesForName[j] == i) {
namesList.add(names[j]);
names[j] = null;
}
}
}
}
}
for (String name : names) {
if (name != null) namesList.add(name);
}
names = ArrayUtil.toStringArray(namesList);
TObjectIntHashMap<String> packageToCountMap = new TObjectIntHashMap<String>();
TObjectIntHashMap<String> classToCountMap = new TObjectIntHashMap<String>();
for (String name : names) {
String packageOrClassName = getPackageOrClassName(name);
if (packageOrClassName.length() == 0) continue;
if (namesToImportStaticly.contains(name)) {
int count = classToCountMap.get(packageOrClassName);
classToCountMap.put(packageOrClassName, count + 1);
} else {
int count = packageToCountMap.get(packageOrClassName);
packageToCountMap.put(packageOrClassName, count + 1);
}
}
final Set<String> classesOrPackagesToImportOnDemand = new THashSet<String>();
class MyVisitorProcedure implements TObjectIntProcedure<String> {
private final boolean myIsVisitingPackages;
MyVisitorProcedure(boolean isVisitingPackages) {
myIsVisitingPackages = isVisitingPackages;
}
public boolean execute(final String packageOrClassName, final int count) {
if (isToUseImportOnDemand(packageOrClassName, count, !myIsVisitingPackages)) {
classesOrPackagesToImportOnDemand.add(packageOrClassName);
}
return true;
}
}
classToCountMap.forEachEntry(new MyVisitorProcedure(false));
packageToCountMap.forEachEntry(new MyVisitorProcedure(true));
Set<String> classesToUseSingle =
findSingleImports(file, names, classesOrPackagesToImportOnDemand, namesToImportStaticly);
try {
final String text =
buildImportListText(
names, classesOrPackagesToImportOnDemand, classesToUseSingle, namesToImportStaticly);
String ext = StdFileTypes.JAVA.getDefaultExtension();
final PsiJavaFile dummyFile =
(PsiJavaFile)
PsiFileFactory.getInstance(file.getProject())
.createFileFromText("_Dummy_." + ext, StdFileTypes.JAVA, text);
codeStyleManager.reformat(dummyFile);
PsiImportList resultList = dummyFile.getImportList();
PsiImportList oldList = file.getImportList();
if (oldList.isReplaceEquivalent(resultList)) return null;
return resultList;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
public LightPackageReference(PsiManager manager, String packageName) {
super(manager, StdFileTypes.JAVA.getLanguage());
myPackageName = packageName;
myRefPackage = null;
}