import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@NotNull
public static VirtualFile[] getLibraryRoots(@NotNull LibraryOrderEntry orderEntry) {
  Library library = orderEntry.getLibrary();
  if (library == null) return VirtualFile.EMPTY_ARRAY;
  OrderRootType[] rootTypes = LibraryType.DEFAULT_EXTERNAL_ROOT_TYPES;
  if (library instanceof LibraryEx) {
    if (((LibraryEx)library).isDisposed()) return VirtualFile.EMPTY_ARRAY;
    PersistentLibraryKind<?> libKind = ((LibraryEx)library).getKind();
    if (libKind != null) {
      rootTypes = LibraryType.findByKind(libKind).getExternalRootTypes();
    }
  }
  final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
  for (OrderRootType rootType : rootTypes) {
    files.addAll(Arrays.asList(library.getFiles(rootType)));
  }
  return VfsUtilCore.toVirtualFileArray(files);
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
private static void addLibrariesFromModule(Module module, Collection<String> list) {
  final OrderEntry[] entries = ModuleRootManager.getInstance(module).getOrderEntries();
  for (OrderEntry entry : entries) {
    if (entry instanceof LibraryOrderEntry) {
      final String name = ((LibraryOrderEntry)entry).getLibraryName();
      if (name != null && name.endsWith(LibraryContributingFacet.PYTHON_FACET_LIBRARY_NAME_SUFFIX)) {
        // skip libraries from Python facet
        continue;
      }
      for (VirtualFile root : ((LibraryOrderEntry)entry).getRootFiles(OrderRootType.CLASSES)) {
        final Library library = ((LibraryOrderEntry)entry).getLibrary();
        if (!PlatformUtils.isPyCharm()) {
          addToPythonPath(root, list);
        }
        else if (library instanceof LibraryImpl) {
          final PersistentLibraryKind<?> kind = ((LibraryImpl)library).getKind();
          if (kind == PythonLibraryType.getInstance().getKind()) {
            addToPythonPath(root, list);
          }
        }
      }
    }
  }
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
private Library createLibraryFromRoots(ModifiableModuleRootLayer layer, List<OrderRoot> roots, @Nullable final LibraryType libraryType) {
  final LibraryTable.ModifiableModel moduleLibraryModel = layer.getModuleLibraryTable().getModifiableModel();

  final PersistentLibraryKind kind = libraryType == null ? null : libraryType.getKind();
  final Library library = ((LibraryTableBase.ModifiableModelEx)moduleLibraryModel).createLibrary(null, kind);
  final LibraryEx.ModifiableModelEx libModel = (LibraryEx.ModifiableModelEx)library.getModifiableModel();

  for (OrderRoot root : roots) {
    if (root.isJarDirectory()) {
      libModel.addJarDirectory(root.getFile(), false, root.getType());
    }
    else {
      libModel.addRoot(root.getFile(), root.getType());
    }
  }
  libModel.commit();
  return library;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Nonnull
static VirtualFile[] getLibraryRoots(@Nonnull LibraryOrderEntry orderEntry) {
  Library library = orderEntry.getLibrary();
  if (library == null) return VirtualFile.EMPTY_ARRAY;
  OrderRootType[] rootTypes = LibraryType.DEFAULT_EXTERNAL_ROOT_TYPES;
  if (library instanceof LibraryEx) {
    if (((LibraryEx)library).isDisposed()) return VirtualFile.EMPTY_ARRAY;
    PersistentLibraryKind<?> libKind = ((LibraryEx)library).getKind();
    if (libKind != null) {
      rootTypes = LibraryType.findByKind(libKind).getExternalRootTypes();
    }
  }
  final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
  for (OrderRootType rootType : rootTypes) {
    files.addAll(Arrays.asList(library.getFiles(rootType)));
  }
  return VfsUtilCore.toVirtualFileArray(files);
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind type) {
  final Library library = getLibrariesModifiableModel().createLibrary(name, type);
  //createLibraryEditor(library);                     \
  final BaseLibrariesConfigurable configurable = ProjectStructureConfigurable.getInstance(myProject).getConfigurableFor(library);
  configurable.createLibraryNode(library);
  return library;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind kind) {
  assertWritable();
  final LibraryImpl library = new LibraryImpl(name, kind, LibraryTableBase.this, null);
  myLibraries.add(library);
  myLibraryByNameCache = null;
  return library;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Nullable
private static Configurable getLibrarySettingsConfigurable(OrderEntry orderEntry) {
  if (!(orderEntry instanceof LibraryOrderEntry)) return null;
  LibraryOrderEntry libOrderEntry = (LibraryOrderEntry)orderEntry;
  Library lib = libOrderEntry.getLibrary();
  if (lib instanceof LibraryEx) {
    Project project = libOrderEntry.getOwnerModule().getProject();
    PersistentLibraryKind<?> libKind = ((LibraryEx)lib).getKind();
    if (libKind != null) {
      return LibrarySettingsProvider.getAdditionalSettingsConfigurable(project, libKind);
    }
  }
  return null;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
public PythonLibraryType() {
  super(
    new PersistentLibraryKind<LibraryVersionProperties>("dummy.type") {
      @NotNull
      @Override
      public LibraryVersionProperties createDefaultProperties() {
        return new LibraryVersionProperties();
      }
    }
  );
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind type) {
  final Library library = ((LibraryTableBase.ModifiableModelEx)getLibrariesModifiableModel()).createLibrary(name, type);
  //createLibraryEditor(library);                     \
  final BaseLibrariesConfigurable configurable = ProjectStructureConfigurable.getInstance(myProject).getConfigurableFor(library);
  configurable.createLibraryNode(library);
  return library;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
protected DownloadableLibraryTypeBase(@NotNull String libraryCategoryName,
                                      @NotNull String libraryTypeId,
                                      @NotNull String groupId,
                                      @NotNull Icon icon,
                                      @NotNull URL... localUrls) {
  super(new PersistentLibraryKind<LibraryVersionProperties>(libraryTypeId) {
    @NotNull
    @Override
    public LibraryVersionProperties createDefaultProperties() {
      return new LibraryVersionProperties();
    }
  }, libraryCategoryName,
        DownloadableLibraryService.getInstance().createLibraryDescription(groupId, localUrls));
  myIcon = icon;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind kind) {
  assertWritable();
  final LibraryImpl library = new LibraryImpl(name, kind, LibraryTableBase.this, null);
  myLibraries.add(library);
  return library;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
protected SandLibraryType() {
  super(new PersistentLibraryKind<DummyLibraryProperties>("sand") {
    @Nonnull
    @Override
    public DummyLibraryProperties createDefaultProperties() {
      return new DummyLibraryProperties();
    }
  });
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Nullable
PersistentLibraryKind<?> getKind();
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public PersistentLibraryKind<?> getKind() {
  return null;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind type) {
  throw new UnsupportedOperationException("'createLibrary' not implemented in " + getClass().getName());
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
public static Library createModuleLevelLibrary(@Nullable String name,
                                               PersistentLibraryKind kind,
                                               @NotNull RootModelImpl rootModel) {
  return new LibraryImpl(name, kind, null, rootModel);
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind kind) {
  LibraryOrderEntry orderEntry = new ModuleLibraryOrderEntryImpl(name, kind, myRootModel, myProjectRootManager);
  myRootModel.addOrderEntry(orderEntry);
  return orderEntry.getLibrary();
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
ModuleLibraryOrderEntryImpl(String name, final PersistentLibraryKind kind, @NotNull RootModelImpl rootModel, @NotNull ProjectRootManagerImpl projectRootManager) {
  super(rootModel, projectRootManager);
  myLibrary = LibraryTableImplUtil.createModuleLevelLibrary(name, kind, getRootModel());
  doinit();
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
public DownloadableLibraryType(@NotNull PersistentLibraryKind<LibraryVersionProperties> kind, @NotNull String libraryCategoryName,
                               @NotNull DownloadableLibraryDescription description) {
  super(kind);
  myLibraryCategoryName = libraryCategoryName;
  myLibraryDescription = description;
}
 

import com.intellij.openapi.roots.libraries.PersistentLibraryKind; //导入依赖的package包/类
public static Library createModuleLevelLibrary(@Nullable String name,
                                               final PersistentLibraryKind kind,
                                               RootModelImpl rootModel) {
  return new LibraryImpl(name, kind, null, rootModel);
}