import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
@Override
public Set<UsageDescriptor> getProjectUsages(@NotNull Project project) {
  final Set<LibraryKind> usedKinds = new HashSet<LibraryKind>();
  final Processor<Library> processor = new Processor<Library>() {
    @Override
    public boolean process(Library library) {
      usedKinds.addAll(LibraryPresentationManagerImpl.getLibraryKinds(library, null));
      return true;
    }
  };
  for (Module module : ModuleManager.getInstance(project).getModules()) {
    ModuleRootManager.getInstance(module).orderEntries().librariesOnly().forEachLibrary(processor);
  }

  final HashSet<UsageDescriptor> usageDescriptors = new HashSet<UsageDescriptor>();
  for (LibraryKind kind : usedKinds) {
    usageDescriptors.add(new UsageDescriptor(kind.getKindId(), 1));
  }
  return usageDescriptors;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
@Override
public ValidationResult check() {
  final Set<? extends LibraryKind> libraryKinds = myLibraryDescription.getSuitableLibraryKinds();
  final Ref<Boolean> found = Ref.create(false);
  myContext.getRootModel().orderEntries().using(myContext.getModulesProvider()).recursively().librariesOnly().forEachLibrary(new Processor<Library>() {
    @Override
    public boolean process(Library library) {
      if (LibraryPresentationManager.getInstance().isLibraryOfKind(library, myContext.getLibrariesContainer(), libraryKinds)) {
        found.set(true);
        return false;
      }
      return true;
    }
  });
  if (found.get()) return ValidationResult.OK;

  return new ValidationResult(IdeBundle.message("label.missed.libraries.text", myLibraryCategoryName), new LibrariesQuickFix(myLibraryDescription));
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@Override
public ValidationResult check() {
  final Set<? extends LibraryKind> libraryKinds = myLibraryDescription.getSuitableLibraryKinds();
  final Ref<Boolean> found = Ref.create(false);
  myContext.getRootModel().orderEntries().using(myContext.getModulesProvider()).recursively().librariesOnly().forEachLibrary(new Processor<Library>() {
    @Override
    public boolean process(Library library) {
      if (LibraryPresentationManager.getInstance().isLibraryOfKind(library, myContext.getLibrariesContainer(), libraryKinds)) {
        found.set(true);
        return false;
      }
      return true;
    }
  });
  if (found.get()) return ValidationResult.OK;

  return new ValidationResult(StringUtil.capitalize(myLibraryCategoryName) + " library not found in the module dependencies list", new LibrariesQuickFix(myLibraryDescription));
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@Nonnull
@Override
public Set<UsageDescriptor> getProjectUsages(@Nonnull Project project) {
  final Set<LibraryKind> usedKinds = new HashSet<LibraryKind>();
  final Processor<Library> processor = new Processor<Library>() {
    @Override
    public boolean process(Library library) {
      usedKinds.addAll(LibraryPresentationManagerImpl.getLibraryKinds(library, null));
      return true;
    }
  };
  for (Module module : ModuleManager.getInstance(project).getModules()) {
    ModuleRootManager.getInstance(module).orderEntries().librariesOnly().forEachLibrary(processor);
  }

  final HashSet<UsageDescriptor> usageDescriptors = new HashSet<UsageDescriptor>();
  for (LibraryKind kind : usedKinds) {
    usageDescriptors.add(new UsageDescriptor(kind.getKindId(), 1));
  }
  return usageDescriptors;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
public void updatePropertiesLabel() {
  StringBuilder text = new StringBuilder();
  final LibraryType<?> type = getLibraryEditor().getType();
  final Set<LibraryKind> excluded =
    type != null ? Collections.<LibraryKind>singleton(type.getKind()) : Collections.<LibraryKind>emptySet();
  for (String description : LibraryPresentationManager.getInstance().getDescriptions(getLibraryEditor().getFiles(OrderRootType.CLASSES),
                                                                                     excluded)) {
    if (text.length() > 0) {
      text.append("\n");
    }
    text.append(description);
  }
  myPropertiesLabel.setText(text.toString());
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@Nullable
public static LibrarySettingsProvider forLibraryType(LibraryKind libType) {
  for (LibrarySettingsProvider provider : Extensions.getExtensions(EP_NAME)) {
    if (provider.getLibraryKind().equals(libType)) {
      return provider;
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
public static Set<? extends LibraryKind> getAllGroovyKinds() {
  final HashSet<LibraryKind> kinds = new HashSet<LibraryKind>();
  for (LibraryPresentationProvider provider : LibraryPresentationProvider.EP_NAME.getExtensions()) {
    if (provider instanceof GroovyLibraryPresentationProviderBase) {
      kinds.add(provider.getKind());
    }
  }
  return kinds;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
public void updatePropertiesLabel() {
  StringBuilder text = new StringBuilder();
  final LibraryType<?> type = getLibraryEditor().getType();
  final Set<LibraryKind> excluded =
    type != null ? Collections.<LibraryKind>singleton(type.getKind()) : Collections.<LibraryKind>emptySet();
  for (String description : LibraryPresentationManager.getInstance().getDescriptions(getLibraryEditor().getFiles(BinariesOrderRootType.getInstance()),
                                                                                     excluded)) {
    if (text.length() > 0) {
      text.append("\n");
    }
    text.append(description);
  }
  myPropertiesLabel.setText(text.toString());
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
private MuleLibraryDescription(@NotNull final Set<? extends LibraryKind> libraryKinds)
{
    myLibraryKinds = libraryKinds;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
@Override
public Set<? extends LibraryKind> getSuitableLibraryKinds()
{
    return myLibraryKinds;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
public abstract List<String> getDescriptions(@NotNull VirtualFile[] classRoots, Set<LibraryKind> excludedKinds);
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
public abstract boolean isLibraryOfKind(@NotNull Library library, @NotNull LibrariesContainer librariesContainer,
@NotNull Set<? extends LibraryKind> acceptedKinds);
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
public abstract Set<? extends LibraryKind> getSuitableLibraryKinds();
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
public abstract Library createLibrary(@NotNull Set<? extends LibraryKind> suitableLibraryKinds);
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
@Override
public Set<? extends LibraryKind> getSuitableLibraryKinds() {
  return Collections.singleton(myLibraryType.getKind());
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
@Override
public Set<? extends LibraryKind> getSuitableLibraryKinds() {
  return Collections.emptySet();
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@NotNull
public abstract LibraryKind getLibraryKind();
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@Nullable
public static Configurable getAdditionalSettingsConfigurable(Project project, LibraryKind libKind) {
  LibrarySettingsProvider provider = forLibraryType(libKind);
  if (provider == null) return null;
  return provider.getAdditionalSettingsConfigurable(project);
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
@Override
public LibraryKind getLibraryKind() {
  return GriffonLibraryPresentationProvider.GRIFFON_KIND;
}
 

import com.intellij.openapi.roots.libraries.LibraryKind; //导入依赖的package包/类
public GroovyLibraryDescription(@NotNull String envVariable, @NotNull LibraryKind libraryKind, String frameworkName) {
  this(envVariable, Collections.singleton(libraryKind), frameworkName);
}