Java DataNode.createChild方法代码示例

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
public void testPopulateModuleContentRootsWithAndroidProject() {
  ProjectData project = myProjectResolver.createProject();
  DataNode<ProjectData> projectNode = new DataNode<ProjectData>(ProjectKeys.PROJECT, project, null);
  ModuleData module = myProjectResolver.createModule(myAndroidModule, project);
  DataNode<ModuleData> moduleDataNode = projectNode.createChild(ProjectKeys.MODULE, module);

  myProjectResolver.populateModuleContentRoots(myAndroidModule, moduleDataNode);

  // Verify module has IdeaAndroidProject.
  Collection<DataNode<IdeaAndroidProject>> androidProjects =
    ExternalSystemApiUtil.getChildren(moduleDataNode, AndroidProjectKeys.IDE_ANDROID_PROJECT);
  assertEquals(1, androidProjects.size());
  DataNode<IdeaAndroidProject> androidProjectNode = ContainerUtil.getFirstItem(androidProjects);
  assertNotNull(androidProjectNode);
  assertSame(myAndroidProject, androidProjectNode.getData().getDelegate());

  // Verify module has IdeaGradleProject.
  Collection<DataNode<IdeaGradleProject>> gradleProjects =
    ExternalSystemApiUtil.getChildren(moduleDataNode, AndroidProjectKeys.IDE_GRADLE_PROJECT);
  assertEquals(1, gradleProjects.size());
  DataNode<IdeaGradleProject> gradleProjectNode = ContainerUtil.getFirstItem(gradleProjects);
  assertNotNull(gradleProjectNode);
  assertEquals(myAndroidModule.getGradleProject().getPath(), gradleProjectNode.getData().getGradlePath());
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
public void testPopulateModuleContentRootsWithJavaProject() {
  ProjectData project = myProjectResolver.createProject();
  DataNode<ProjectData> projectNode = new DataNode<ProjectData>(ProjectKeys.PROJECT, project, null);
  ModuleData module = myProjectResolver.createModule(myUtilModule, project);
  DataNode<ModuleData> moduleDataNode = projectNode.createChild(ProjectKeys.MODULE, module);

  myProjectResolver.populateModuleContentRoots(myUtilModule, moduleDataNode);

  // Verify module does not have IdeaAndroidProject.
  Collection<DataNode<IdeaAndroidProject>> androidProjects =
    ExternalSystemApiUtil.getChildren(moduleDataNode, AndroidProjectKeys.IDE_ANDROID_PROJECT);
  assertEquals(0, androidProjects.size());

  // Verify module has IdeaGradleProject.
  Collection<DataNode<IdeaGradleProject>> gradleProjects =
    ExternalSystemApiUtil.getChildren(moduleDataNode, AndroidProjectKeys.IDE_GRADLE_PROJECT);
  assertEquals(1, gradleProjects.size());
  DataNode<IdeaGradleProject> gradleProjectNode = ContainerUtil.getFirstItem(gradleProjects);
  assertNotNull(gradleProjectNode);
  assertEquals(myUtilModule.getGradleProject().getPath(), gradleProjectNode.getData().getGradlePath());
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  final List<War> warModels;
  final WebConfiguration webConfiguration = resolverCtx.getExtraProject(gradleModule, WebConfiguration.class);
  if (webConfiguration != null) {
    warModels = ContainerUtil.map(webConfiguration.getWarModels(), new Function<WebConfiguration.WarModel, War>() {
        @Override
        public War fun(WebConfiguration.WarModel model) {
          War war = new War(model.getWarName(), model.getWebAppDirName(), model.getWebAppDir());
          war.setWebXml(model.getWebXml());
          war.setWebResources(map(model.getWebResources()));
          war.setClasspath(model.getClasspath());
          war.setManifestContent(model.getManifestContent());
          return war;
        }
      });
    ideModule.createChild(WebConfigurationModelData.KEY, new WebConfigurationModelData(GradleConstants.SYSTEM_ID, warModels));
  }
  nextResolver.populateModuleExtraModels(gradleModule, ideModule);
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(gradleModule, BuildScriptClasspathModel.class);
  final List<BuildScriptClasspathData.ClasspathEntry> classpathEntries;
  if (buildScriptClasspathModel != null) {
    classpathEntries = ContainerUtil
      .map(buildScriptClasspathModel.getClasspath(), new Function<ClasspathEntryModel, BuildScriptClasspathData.ClasspathEntry>() {
        @Override
        public BuildScriptClasspathData.ClasspathEntry fun(ClasspathEntryModel model) {
          return new BuildScriptClasspathData.ClasspathEntry(model.getClasses(), model.getSources(), model.getJavadoc());
        }
      });
  }
  else {
    classpathEntries = ContainerUtil.emptyList();
  }
  BuildScriptClasspathData buildScriptClasspathData = new BuildScriptClasspathData(GradleConstants.SYSTEM_ID, classpathEntries);
  ideModule.createChild(BuildScriptClasspathData.KEY, buildScriptClasspathData);
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
private void createJavaProject(@NotNull IdeaModule gradleModule,
                               @NotNull DataNode<ModuleData> ideModule,
                               boolean androidProjectWithoutVariants) {
  ModuleExtendedModel model = resolverCtx.getExtraProject(gradleModule, ModuleExtendedModel.class);
  IdeaJavaProject javaProject = newJavaProject(gradleModule, model, androidProjectWithoutVariants);
  ideModule.createChild(IDE_JAVA_PROJECT, javaProject);
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@NotNull
private static DataNode<ModuleData> createModule(@NotNull String name, boolean isGradleProject) {
  String path = "~/project/" + name;
  ModuleData data = new ModuleData(name, GradleConstants.SYSTEM_ID, StdModuleTypes.JAVA.getId(), name, path, path);
  DataNode<ModuleData> module = new DataNode<ModuleData>(MODULE, data, null);
  if (isGradleProject) {
    List<String> taskNames = Collections.emptyList();
    module.createChild(IDE_GRADLE_PROJECT, new IdeaGradleProject("app", taskNames, ":" + name, null, null));
  }
  return module;
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  ScalaModel scalaModel = resolverCtx.getExtraProject(gradleModule, ScalaModel.class);
  if (scalaModel != null) {
    ScalaModelData scalaModelData = create(scalaModel);
    ideModule.createChild(ScalaModelData.KEY, scalaModelData);
  }

  nextResolver.populateModuleExtraModels(gradleModule, ideModule);
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateProjectExtraModels(@NotNull IdeaProject gradleProject, @NotNull DataNode<ProjectData> ideProject) {
  final ExternalProject externalProject = resolverCtx.getExtraProject(ExternalProject.class);
  if (externalProject != null) {
    ideProject.createChild(ExternalProjectDataService.KEY, externalProject);
    ideProject.getData().setDescription(externalProject.getDescription());
  }
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateModuleContentRoots(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  ImportedModule importedModule = new ImportedModule(gradleModule);
  ideModule.createChild(AndroidProjectKeys.IMPORTED_MODULE, importedModule);

  GradleProject gradleProject = gradleModule.getGradleProject();
  GradleScript buildScript = null;
  try {
    buildScript = gradleProject.getBuildScript();
  } catch (UnsupportedOperationException ignore) {}

  if (buildScript == null || !inAndroidGradleProject(gradleModule)) {
    nextResolver.populateModuleContentRoots(gradleModule, ideModule);
    return;
  }

  File moduleFilePath = new File(toSystemDependentName(ideModule.getData().getModuleFilePath()));
  File moduleRootDirPath = moduleFilePath.getParentFile();

  AndroidProject androidProject = resolverCtx.getExtraProject(gradleModule, AndroidProject.class);

  boolean androidProjectWithoutVariants = false;
  if (androidProject != null) {
    Variant selectedVariant = getVariantToSelect(androidProject);
    if (selectedVariant == null) {
      // If an Android project does not have variants, it would be impossible to build. This is a possible but invalid use case.
      // For now we are going to treat this case as a Java library module, because everywhere in the IDE (e.g. run configurations,
      // editors, test support, variants tool window, project building, etc.) we have the assumption that there is at least one variant
      // per Android project, and changing that in the code base is too risky, for very little benefit.
      // See https://code.google.com/p/android/issues/detail?id=170722
      androidProjectWithoutVariants = true;
    }
    else {
      IdeaAndroidProject ideaAndroidProject = new IdeaAndroidProject(GRADLE_SYSTEM_ID, gradleModule.getName(), moduleRootDirPath,
                                                                     androidProject, selectedVariant.getName(), DEFAULT_TEST_ARTIFACT);
      ideModule.createChild(IDE_ANDROID_PROJECT, ideaAndroidProject);
    }
  }

  File gradleSettingsFile = new File(moduleRootDirPath, FN_SETTINGS_GRADLE);
  if (gradleSettingsFile.isFile() && androidProject == null) {
    // This is just a root folder for a group of Gradle projects. We don't set an IdeaGradleProject so the JPS builder won't try to
    // compile it using Gradle. We still need to create the module to display files inside it.
    createJavaProject(gradleModule, ideModule, false);
    return;
  }

  BuildScriptClasspathModel buildScriptModel = resolverCtx.getExtraProject(BuildScriptClasspathModel.class);
  String gradleVersion = buildScriptModel != null ? buildScriptModel.getGradleVersion() : null;

  File buildFilePath = buildScript.getSourceFile();
  IdeaGradleProject ideaGradleProject = newIdeaGradleProject(gradleModule.getName(), gradleProject, buildFilePath, gradleVersion);
  ideModule.createChild(IDE_GRADLE_PROJECT, ideaGradleProject);

  if (androidProject == null || androidProjectWithoutVariants) {
    // This is a Java lib module.
    createJavaProject(gradleModule, ideModule, androidProjectWithoutVariants);
  }
}
 

import com.intellij.openapi.externalSystem.model.DataNode; //导入方法依赖的package包/类
@Override
public void populateModuleContentRoots(@NotNull IdeaModule gradleModule,
                                       @NotNull DataNode<ModuleData> ideModule) {
  DomainObjectSet<? extends IdeaContentRoot> contentRoots;
  ModuleExtendedModel moduleExtendedModel = resolverCtx.getExtraProject(gradleModule, ModuleExtendedModel.class);
  if (moduleExtendedModel != null) {
    contentRoots = moduleExtendedModel.getContentRoots();
  }
  else {
    contentRoots = gradleModule.getContentRoots();
  }

  if (contentRoots == null) {
    return;
  }
  for (IdeaContentRoot gradleContentRoot : contentRoots) {
    if (gradleContentRoot == null) continue;

    File rootDirectory = gradleContentRoot.getRootDirectory();
    if (rootDirectory == null) continue;

    ContentRootData ideContentRoot = new ContentRootData(GradleConstants.SYSTEM_ID, rootDirectory.getAbsolutePath());
    ideModule.getData().setModuleFileDirectoryPath(ideContentRoot.getRootPath());
    populateContentRoot(ideContentRoot, ExternalSystemSourceType.SOURCE, gradleContentRoot.getSourceDirectories());
    populateContentRoot(ideContentRoot, ExternalSystemSourceType.TEST, gradleContentRoot.getTestDirectories());

    if (gradleContentRoot instanceof ExtIdeaContentRoot) {
      ExtIdeaContentRoot extIdeaContentRoot = (ExtIdeaContentRoot)gradleContentRoot;
      populateContentRoot(ideContentRoot, ExternalSystemSourceType.RESOURCE, extIdeaContentRoot.getResourceDirectories());
      populateContentRoot(ideContentRoot, ExternalSystemSourceType.TEST_RESOURCE, extIdeaContentRoot.getTestResourceDirectories());
    }

    Set<File> excluded = gradleContentRoot.getExcludeDirectories();
    if (excluded != null) {
      for (File file : excluded) {
        ideContentRoot.storePath(ExternalSystemSourceType.EXCLUDED, file.getAbsolutePath());
      }
    }
    ideModule.createChild(ProjectKeys.CONTENT_ROOT, ideContentRoot);
  }
}