Java JpsModuleDependency类代码示例

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
private static void collectAndroidDependencies(@NotNull JpsModule module,
                                               @NotNull MyAndroidDeps result,
                                               @NotNull Set<String> visitedSet,
                                               boolean fillLibs,
                                               boolean recursively) {
  final List<JpsDependencyElement> dependencies =
    new ArrayList<JpsDependencyElement>(JpsJavaExtensionService.getInstance().getDependencies(
      module, JpsJavaClasspathKind.PRODUCTION_RUNTIME, false));

  for (int i = dependencies.size() - 1; i >= 0; i--) {
    final JpsDependencyElement item = dependencies.get(i);

    if (item instanceof JpsModuleDependency) {
      final JpsModule depModule = ((JpsModuleDependency)item).getModule();
      if (depModule != null) {
        final JpsAndroidModuleExtension depExtension = AndroidJpsUtil.getExtension(depModule);
        if (depExtension != null && visitedSet.add(depModule.getName())) {

          if (recursively) {
            final boolean newRecursively = AndroidJpsUtil.shouldProcessDependenciesRecursively(depModule);
            collectAndroidDependencies(depModule, result, visitedSet, fillLibs && depExtension.isLibrary(), newRecursively);
          }
          result.myAndroidDeps.add(depExtension);

          if (fillLibs && depExtension.isLibrary()) {
            result.myLibAndroidDeps.add(depExtension);
          }
        }
      }
    }
  }
}
 

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
private static void checkAndroidDependencies(@NotNull Map<JpsModule, MyModuleData> moduleDataMap, @NotNull CompileContext context) {
  for (Map.Entry<JpsModule, MyModuleData> entry : moduleDataMap.entrySet()) {
    final JpsModule module = entry.getKey();
    final MyModuleData moduleData = entry.getValue();
    final JpsAndroidModuleExtension extension = moduleData.getAndroidExtension();

    if (extension.isLibrary()) {
      continue;
    }

    for (JpsDependencyElement item : JpsJavaExtensionService.getInstance()
      .getDependencies(module, JpsJavaClasspathKind.PRODUCTION_RUNTIME, false)) {
      if (item instanceof JpsModuleDependency) {
        final JpsModule depModule = ((JpsModuleDependency)item).getModule();
        if (depModule != null) {
          final JpsAndroidModuleExtension depExtension = AndroidJpsUtil.getExtension(depModule);

          if (depExtension != null && !depExtension.isLibrary()) {
            String message = "Suspicious module dependency " + module.getName() + " -> " + depModule.getName() +
                             ": Android application module depends on other application module. Possibly, you should " +
                             "change type of module '" + depModule.getName() +
                             "' to 'Library' or change the dependency scope to 'Provided'.";
            context.processMessage(new CompilerMessage(ANDROID_VALIDATOR, BuildMessage.Kind.WARNING, message));
          }
        }
      }
    }
  }
}
 

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
private static void fillDepsRecursively(@NotNull JpsModule root,
                                        @NotNull Set<JpsModule> libModules,
                                        @NotNull Set<String> externalJars,
                                        @NotNull BuildDataPaths dataPaths,
                                        @NotNull AndroidPlatform platform) {
  for (String jarOrLibDirPath : AndroidJpsUtil.getExternalLibraries(dataPaths, root, platform, false, false, true)) {
    final String path = FileUtil.toCanonicalPath(jarOrLibDirPath);

    if (path != null) {
      externalJars.add(path);
    }
  }

  for (JpsDependencyElement dependencyElement : root.getDependenciesList().getDependencies()) {
    if (dependencyElement instanceof JpsModuleDependency) {
      final JpsModule depModule = ((JpsModuleDependency)dependencyElement).getModule();

      if (depModule != null) {
        final JpsAndroidModuleExtension depExtension = AndroidJpsUtil.getExtension(depModule);

        if (depExtension != null && depExtension.isLibrary()) {
          if (libModules.add(depModule)) {
            fillDepsRecursively(depModule, libModules, externalJars, dataPaths, platform);
          }
        }
      }
    }
  }
}
 

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
private void buildClassPath(JpsModule module, Set<JpsModule> visited) {
    if (!visited.add(module)) {
        return;
    }
    File output = JpsJavaExtensionService.getInstance().getOutputDirectory(module, false);
    if (output != null) {
        classPathEntries.add(output.getPath());
    }

    for (JpsModuleSourceRoot sourceRoot : module.getSourceRoots()) {
        buildStrategy.addSourcesDirectory(sourceRoot.getFile().getAbsolutePath());
    }

    for (JpsDependencyElement dependency : module.getDependenciesList().getDependencies()) {
        if (dependency instanceof JpsModuleDependency) {
            JpsModuleDependency moduleDependency = (JpsModuleDependency) dependency;
            buildClassPath(moduleDependency.getModule(), visited);
        } else if (dependency instanceof JpsLibraryDependency) {
            JpsLibrary library = ((JpsLibraryDependency) dependency).getLibrary();
            if (library == null) {
                continue;
            }
            classPathEntries.addAll(library.getFiles(JpsOrderRootType.COMPILED).stream().map(File::getPath)
                    .collect(toList()));

            for (JpsLibraryRoot libraryRoot : library.getRoots(JpsOrderRootType.SOURCES)) {
                File file = getFileFromUrl(libraryRoot.getUrl());
                if (file != null) {
                    if (file.isDirectory()) {
                        buildStrategy.addSourcesDirectory(file.getAbsolutePath());
                    } else {
                        buildStrategy.addSourcesJar(file.getAbsolutePath());
                    }
                }
            }
        }
    }
}
 

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
private static void addExportedDependency(JpsModule main, JpsModule dep) {
  JpsModuleDependency dependency = main.getDependenciesList().addModuleDependency(dep);
  JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(dependency).setExported(true);
}
 

import org.jetbrains.jps.model.module.JpsModuleDependency; //导入依赖的package包/类
public JpsModuleOrderEntry(JpsRootModel rootModel, JpsModuleDependency dependencyElement) {
  super(rootModel, dependencyElement);
}