Java Module类代码示例

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@Nullable
@Override
public MetadataNode findDeepestExactMatch(Project project, Module module,
    List<String> containerElements) {
  if (moduleNameToSanitisedRootSearchIndex.containsKey(module.getName())) {
    String[] pathSegments =
        containerElements.stream().flatMap(element -> stream(toPathSegments(element)))
            .toArray(String[]::new);
    MetadataNode searchStartNode = moduleNameToSanitisedRootSearchIndex.get(module.getName())
        .get(MetadataNode.sanitize(pathSegments[0]));
    if (searchStartNode != null) {
      if (pathSegments.length > 1) {
        return searchStartNode.findDeepestMatch(pathSegments, 1, true);
      }
      return searchStartNode;
    }
  }
  return null;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
public static Module getIjModule( PsiElement element )
{
  Module module = ModuleUtil.findModuleForPsiElement( element );
  if( module != null )
  {
    return module;
  }

  ManifoldPsiClass javaFacadePsiClass = element.getContainingFile().getUserData( ManifoldPsiClass.KEY_MANIFOLD_PSI_CLASS );
  if( javaFacadePsiClass != null )
  {
    return javaFacadePsiClass.getModule();
  }

  return null;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
public static String getAndroidSdkPath(Project project) {
    ModuleManager manager = ModuleManager.getInstance(project);
    String androidSdkPath = null;

    for (Module module : manager.getModules()) {
        if (androidSdkPath != null) {
            break;
        }
        Sdk sdk = ModuleRootManager.getInstance(module).getSdk();

        if (sdk != null && sdk.getHomePath() != null) {
            File file = new File(sdk.getHomePath());
            String[] contents = file.list();

            if (contents != null) {
                for (String path : contents) {
                    if (path.equals("build-tools")) {
                        androidSdkPath = sdk.getHomePath();
                        break;
                    }
                }
            }
        }
    }
    return androidSdkPath;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
private static boolean dependencyChainContains( Module ijModule, String path, List<Module> visited )
{
  if( !visited.contains( ijModule ) )
  {
    visited.add( ijModule );

    ModuleRootManager rootManager = ModuleRootManager.getInstance( ijModule );
    for( Module dep : rootManager.getDependencies() )
    {
      if( getDirectClassPaths( dep ).contains( path ) || dependencyChainContains( dep, path, visited ) )
      {
        return true;
      }
    }
  }
  return false;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
private boolean isInterfaceMadeStructuralByExtension( PsiClass psiExtentionInterface )
{
  Module module = ManProject.getIjModule( psiExtentionInterface );
  if( module != null )
  {
    if( isInterfaceMadeStructuralByExtension( psiExtentionInterface, ManProject.getModule( module ) ) )
    {
      return true;
    }
  }
  else
  {
    ManProject manProject = ManProject.manProjectFrom( psiExtentionInterface.getProject() );
    for( ManModule manModule : manProject.getModules() )
    {
      if( isInterfaceMadeStructuralByExtension( psiExtentionInterface, manModule ) )
      {
        return true;
      }
    }
  }
  return false;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
public static List<IDirectory> getClassPaths( Module ijModule )
{
  List<String> paths = getDirectClassPaths( ijModule );
  for( Iterator<String> it = paths.iterator(); it.hasNext(); )
  {
    String url = it.next();
    if( dependencyChainContains( ijModule, url, new ArrayList<>() ) )
    {
      it.remove();
    }
  }
  List<IDirectory> dirs = new ArrayList<>();
  for( String path : paths )
  {
    dirs.add( manProjectFrom( ijModule ).getFileSystem().getIDirectory( new File( path ) ) );
  }
  return dirs;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
private void configureModuleDependencies(
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Module module,
    @NotNull final Collection<Module> allModules,
    @NotNull final Set<HybrisModuleDescriptor> extModules,
    final @NotNull IdeModifiableModelsProvider modifiableModelsProvider
) {
    final ModifiableRootModel rootModel = modifiableModelsProvider.getModifiableRootModel(module);

    for (HybrisModuleDescriptor dependency : moduleDescriptor.getDependenciesTree()) {
        if (moduleDescriptor instanceof OotbHybrisModuleDescriptor) {
            if (extModules.contains(dependency)) {
                continue;
            }
        }

        Optional<Module> targetDependencyModule = findModuleByNameIgnoreCase(allModules, dependency.getName());
        final ModuleOrderEntry moduleOrderEntry = targetDependencyModule.isPresent()
            ? rootModel.addModuleOrderEntry(targetDependencyModule.get())
            : rootModel.addInvalidModuleEntry(dependency.getName());

        moduleOrderEntry.setExported(true);
        moduleOrderEntry.setScope(DependencyScope.COMPILE);
    }
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
private void moveGradleModulesToGroup(
    final Project project,
    final List<Module> gradleModules,
    final String[] gradleGroup
) {
    final ModifiableModuleModel modifiableModuleModel = ModuleManager.getInstance(project).getModifiableModel();

    for (Module module : gradleModules) {
        if (module == null) {
            // https://youtrack.jetbrains.com/issue/IDEA-177512
            continue;
        }
        module.setOption(HybrisConstants.DESCRIPTOR_TYPE, HybrisModuleDescriptorType.GRADLE.name());
        modifiableModuleModel.setModuleGroupPath(module, gradleGroup);
    }
    AccessToken token = null;
    try {
        token = ApplicationManager.getApplication().acquireWriteActionLock(getClass());
        modifiableModuleModel.commit();
    } finally {
        if (token != null) {
            token.finish();
        }
    }
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@NotNull
@Override
public Module createModule(@NotNull ModifiableModuleModel moduleModel) throws InvalidDataException, IOException, ModuleWithNameAlreadyExists, JDOMException, ConfigurationException {
  Module baseModule = super.createModule(moduleModel);
  Project project = baseModule.getProject();
  EduProjectGenerator generator = new EduProjectGenerator();
  if (myCourse == null) {
    File courseRoot = StudyUtils.getBundledCourseRoot(DEFAULT_COURSE_NAME, EduKotlinKoansModuleBuilder.class);
    final Course course = generator.addLocalCourse(FileUtil.join(courseRoot.getPath(), DEFAULT_COURSE_NAME));
    if (course == null) {
      LOG.info("Failed to find course " + DEFAULT_COURSE_NAME);
      return baseModule;
    }
  }
  myCourse.setLanguage("kotlin");
  EduModuleBuilderUtils.createCourseFromCourseInfo(moduleModel, project, generator, myCourse, getModuleFileDirectory());
  return baseModule;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@NotNull
public Parameters getParameters() {
    if (parameters == null) {
        parameters = new Parameters();
        parameters.existingModuleNames = new HashSet<>();
        if (isUpdate()) {
            Project project = getCurrentProject();
            if (project != null) {
                for (Module module : ModuleManager.getInstance(project).getModules()) {
                    parameters.existingModuleNames.add(module.getName());
                }
            }
        }
    }

    return parameters;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@Nullable
@Override
public List<Module> commit(Project project,
                           ModifiableModuleModel modifiableModuleModel,
                           ModulesProvider modulesProvider,
                           ModifiableArtifactModel modifiableArtifactModel) {

    logger.debug("Initializing module builder instance.");
    ProcessingModuleBuilder processingModuleBuilder = new ProcessingModuleBuilder();
    processingModuleBuilder.setGenerateTemplateSketchClass(false);

    logger.debug("Creating modules for project '" + project + "' at path '" + getParameters().projectCreationRoot + "'.");

    List<Module> modules = processingModuleBuilder.commit(project, modifiableModuleModel, modulesProvider);

    Collection<VirtualFile> importablePdeFiles = new LinkedList<>(getParameters().importablePdeFiles);

    logger.info("Identified a total of " + importablePdeFiles.size() + " PDE files for import from '" + getParameters().root + "'.");

    ImportSketchClasses importSketchClasses = new ImportSketchClasses(this, project, modules, importablePdeFiles);
    DumbService.getInstance(project).smartInvokeLater(importSketchClasses);

    return modules;
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
private static void removeOldProjectData(@NotNull final Project project) {
    final ModifiableModuleModel moduleModel = ModuleManager.getInstance(project).getModifiableModel();

    for (Module module : moduleModel.getModules()) {
        moduleModel.disposeModule(module);
    }
    final LibraryTable.ModifiableModel libraryModel = ProjectLibraryTable.getInstance(project).getModifiableModel();

    for (Library library : libraryModel.getLibraries()) {
        libraryModel.removeLibrary(library);
    }
    ApplicationManager.getApplication().runWriteAction(() -> {
        moduleModel.commit();
        libraryModel.commit();
    });
    final GradleSupport gradleSupport = GradleSupport.getInstance();

    if (gradleSupport != null) {
        gradleSupport.clearLinkedProjectSettings(project);
    }
    final AntConfigurationBase antConfiguration = AntConfigurationBase.getInstance(project);

    for (AntBuildFile antBuildFile : antConfiguration.getBuildFiles()) {
        antConfiguration.removeBuildFile(antBuildFile);
    }
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@Nullable
public static ModuleDepDiagramItem fromFQN(@NotNull final String fqn, @NotNull final Project project) {
    String moduleName = null;
    boolean customExtension = false;

    if (fqn.startsWith(MODULE_PREFIX)) {
        moduleName = fqn.substring(MODULE_PREFIX.length());
        customExtension = false;
    } else if (fqn.startsWith(CUSTOM_MODULE_PREFIX)) {
        moduleName = fqn.substring(CUSTOM_MODULE_PREFIX.length());
        customExtension = true;
    }
    if (moduleName == null) {
        return new ModuleDepDiagramItem(null, false);
    }
    final Module module = ModuleManager.getInstance(project).findModuleByName(moduleName);
    return module == null ? null : new ModuleDepDiagramItem(module, customExtension);
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@NotNull
private List<ModuleDepDiagramEdge> createAdaptedEdges(@NotNull final Collection<ModulesUmlEdge> edges) {
    final DiagramProvider provider = getBuilder().getProvider();

    return edges
        .stream()
        .map(modulesUmlEdge -> {
            final Module from = modulesUmlEdge.getSource().getIdentifyingElement().getModule();
            final ModuleDepDiagramItem fromItem = new ModuleDepDiagramItem(from, isCustomExtension(from));

            final Module to = modulesUmlEdge.getTarget().getIdentifyingElement().getModule();
            final ModuleDepDiagramItem toItem = new ModuleDepDiagramItem(to, isCustomExtension(to));

            return new ModuleDepDiagramEdge(
                new ModuleDepDiagramNode(fromItem, provider),
                new ModuleDepDiagramNode(toItem, provider),
                modulesUmlEdge.getRelationship()
            );
        }).collect(Collectors.toList());
}
 

import com.intellij.openapi.module.Module; //导入依赖的package包/类
public static boolean isCustomExtensionFile(@NotNull final VirtualFile file, @NotNull final Project project) {
    final Module module = ModuleUtilCore.findModuleForFile(file, project);

    if (null == module) {
        return false;
    }
    final String descriptorTypeName = module.getOptionValue(HybrisConstants.DESCRIPTOR_TYPE);

    if (descriptorTypeName == null) {
        if (shouldCheckFilesWithoutHybrisSettings(project)) {
            return estimateIsCustomExtension(file);
        }
        return false;
    }

    final HybrisModuleDescriptorType descriptorType = HybrisModuleDescriptorType.valueOf(descriptorTypeName);
    return descriptorType == HybrisModuleDescriptorType.CUSTOM;
}