Java ExternalLibraryDescriptor类代码示例

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
private String selectVersion(@NotNull ExternalLibraryDescriptor descriptor) {
  Set<String> versions = myIndicesManager.getVersions(descriptor.getLibraryGroupId(), descriptor.getLibraryArtifactId());
  List<String> suitableVersions = new ArrayList<String>();
  String minVersion = descriptor.getMinVersion();
  String maxVersion = descriptor.getMaxVersion();
  for (String version : versions) {
    if ((minVersion == null || VersionComparatorUtil.compare(minVersion, version) <= 0)
        && (maxVersion == null || VersionComparatorUtil.compare(version, maxVersion) < 0)) {
      suitableVersions.add(version);
    }
  }
  if (suitableVersions.isEmpty()) {
    return null;
  }
  return Collections.max(suitableVersions, VersionComparatorUtil.COMPARATOR);
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Override
public void configureModule(@NotNull Module module) {
  ExternalLibraryDescriptor descriptor = JUnitExternalLibraryDescriptor.JUNIT4;
  List<String> defaultRoots = descriptor.getLibraryClassesRoots();
  final List<String> urls = OrderEntryFix.refreshAndConvertToUrls(defaultRoots);
  ModuleRootModificationUtil.addModuleLibrary(module, descriptor.getPresentableName(), urls, Collections.emptyList());
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public ExternalLibraryDescriptor resolvePackage(@NotNull String packageName) {
  if (packageName.equals("net.jcip.annotations")) {
    return JDCIP_LIBRARY_DESCRIPTOR;
  }
  return null;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
public AddExternalLibraryToDependenciesQuickFix(@NotNull Module currentModule,
                                                @NotNull ExternalLibraryDescriptor libraryDescriptor, @NotNull PsiReference reference,
                                                @Nullable String qualifiedClassName) {
  myCurrentModule = currentModule;
  myReference = reference;
  myLibraryDescriptor = libraryDescriptor;
  myQualifiedClassName = qualifiedClassName;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public ExternalClassResolveResult resolveClass(@NotNull String shortClassName, @NotNull ThreeState isAnnotation, @NotNull Module contextModule) {
  if (AnnotationUtil.isJetbrainsAnnotation(shortClassName)) {
    ExternalLibraryDescriptor libraryDescriptor = getAnnotationsLibraryDescriptor(contextModule);
    return new ExternalClassResolveResult("org.jetbrains.annotations." + shortClassName, libraryDescriptor);
  }
  return null;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Override
public Promise<Void> addDependency(@NotNull Collection<Module> from, @NotNull ExternalLibraryDescriptor libraryDescriptor, @NotNull DependencyScope scope) {
  for (JavaProjectModelModifier modifier : getModelModifiers()) {
    Promise<Void> promise = modifier.addExternalLibraryDependency(from, libraryDescriptor, scope);
    if (promise != null) {
      return promise;
    }
  }
  return Promise.REJECTED;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public String getLibraryPath() {
  ExternalLibraryDescriptor descriptor = getFrameworkLibraryDescriptor();
  if (descriptor != null) {
    return descriptor.getLibraryClassesRoots().get(0);
  }
  return null;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
public void setupLibrary(Module module) {
  ExternalLibraryDescriptor descriptor = getFrameworkLibraryDescriptor();
  if (descriptor != null) {
    JavaProjectModelModificationService.getInstance(module.getProject()).addDependency(module, descriptor, DependencyScope.TEST);
  }
  else {
    String path = getLibraryPath();
    if (path != null) {
      OrderEntryFix.addJarsToRoots(Collections.singletonList(path), null, module, null);
    }
  }
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public ExternalLibraryDescriptor resolvePackage(@NotNull String packageName) {
  if (packageName.equals("org.junit")) {
    return JUnitExternalLibraryDescriptor.JUNIT4;
  }
  if (packageName.equals("junit.framework")) {
    return JUnitExternalLibraryDescriptor.JUNIT3;
  }
  return null;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public Promise<Void> addExternalLibraryDependency(@NotNull Collection<Module> modules,
                                                  @NotNull ExternalLibraryDescriptor descriptor,
                                                  @NotNull DependencyScope scope) {
  for (Module module : modules) {
    if (!myProjectsManager.isMavenizedModule(module)) {
      return null;
    }
  }

  String version = selectVersion(descriptor);
  MavenId mavenId = new MavenId(descriptor.getLibraryGroupId(), descriptor.getLibraryArtifactId(), version);
  return addDependency(modules, mavenId, scope);
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Nullable
@Override
public String getLibraryPath()
{
	ExternalLibraryDescriptor descriptor = getFrameworkLibraryDescriptor();
	if(descriptor != null)
	{
		return descriptor.getLibraryClassesRoots().get(0);
	}
	return null;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
public AddExternalLibraryToDependenciesQuickFix(@NotNull Module currentModule,
		@NotNull ExternalLibraryDescriptor libraryDescriptor,
		@NotNull PsiReference reference,
		@Nullable String qualifiedClassName)
{
	super(reference);
	myCurrentModule = currentModule;
	myLibraryDescriptor = libraryDescriptor;
	myQualifiedClassName = qualifiedClassName;
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Override
public AsyncResult<Void> addDependency(@NotNull Collection<Module> from, @NotNull ExternalLibraryDescriptor libraryDescriptor, @NotNull DependencyScope scope)
{
	for(JavaProjectModelModifier modifier : getModelModifiers())
	{
		AsyncResult<Void> asyncResult = modifier.addExternalLibraryDependency(from, libraryDescriptor, scope);
		if(asyncResult != null)
		{
			return asyncResult;
		}
	}
	return AsyncResult.rejected();
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@Override
public AsyncResult<Void> addExternalLibraryDependency(@NotNull final Collection<Module> modules, @NotNull final ExternalLibraryDescriptor descriptor, @NotNull final DependencyScope scope)
{
	List<String> defaultRoots = descriptor.getLibraryClassesRoots();
	Module firstModule = ContainerUtil.getFirstItem(modules);
	LOG.assertTrue(firstModule != null);
	LocateLibraryDialog dialog = new LocateLibraryDialog(firstModule, defaultRoots, descriptor.getPresentableName());
	List<String> classesRoots = dialog.showAndGetResult();
	if(!classesRoots.isEmpty())
	{
		String libraryName = classesRoots.size() > 1 ? descriptor.getPresentableName() : null;
		final List<String> urls = OrderEntryFix.refreshAndConvertToUrls(classesRoots);
		if(modules.size() == 1)
		{
			ModuleRootModificationUtil.addModuleLibrary(firstModule, libraryName, urls, Collections.emptyList(), scope);
		}
		else
		{
			new WriteAction()
			{
				protected void run(@NotNull Result result)
				{
					Library library = LibraryUtil.createLibrary(LibraryTablesRegistrar.getInstance().getLibraryTable(myProject), descriptor.getPresentableName());
					Library.ModifiableModel model = library.getModifiableModel();
					for(String url : urls)
					{
						model.addRoot(url, OrderRootType.CLASSES);
					}
					model.commit();
					for(Module module : modules)
					{
						ModuleRootModificationUtil.addDependency(module, library, scope, false);
					}
				}
			}.execute();
		}
	}
	return AsyncResult.done(null);
}
 

import com.intellij.openapi.roots.ExternalLibraryDescriptor; //导入依赖的package包/类
@NotNull
public static ExternalLibraryDescriptor getAnnotationsLibraryDescriptor(@NotNull Module contextModule) {
  boolean java8 = EffectiveLanguageLevelUtil.getEffectiveLanguageLevel(contextModule).isAtLeast(LanguageLevel.JDK_1_8);
  return java8 ? JAVA8 : JAVA5;
}