import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
/**
 * Creates a new {@link IdeaGradleProject}.
 * @param moduleName    the name of the IDEA module.
 * @param gradleProject the Gradle project.
 * @param buildFile     the build.gradle file.
 * @param gradleVersion the version of Gradle used to sync the project.
 */
public static IdeaGradleProject newIdeaGradleProject(@NotNull String moduleName,
                                                     @NotNull GradleProject gradleProject,
                                                     @Nullable File buildFile,
                                                     @Nullable String gradleVersion) {
  List<String> taskNames = Lists.newArrayList();
  DomainObjectSet<? extends GradleTask> tasks = gradleProject.getTasks();
  if (!tasks.isEmpty()) {
    for (GradleTask task : tasks) {
      String name = task.getName();
      if (isNotEmpty(name)) {
        taskNames.add(task.getProject().getPath() + SdkConstants.GRADLE_PATH_SEPARATOR + task.getName());
      }
    }
  }

  return new IdeaGradleProject(moduleName, taskNames, gradleProject.getPath(), buildFile, gradleVersion);
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
protected <T> Map<String, T> getModulesMap(final Class<T> aClass) {
  final DomainObjectSet<? extends IdeaModule> ideaModules = allModels.getIdeaProject().getModules();

  final String filterKey = "to_filter";
  final Map<String, T> map = ContainerUtil.map2Map(ideaModules, new Function<IdeaModule, Pair<String, T>>() {
    @Override
    public Pair<String, T> fun(IdeaModule module) {
      final T value = allModels.getExtraProject(module, aClass);
      final String key = value != null ? module.getGradleProject().getPath() : filterKey;
      return Pair.create(key, value);
    }
  });

  map.remove(filterKey);
  return map;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
Collection<Object> createEmptyCollection(Class<?> collectionType) {
    if (collectionType.equals(DomainObjectSet.class)) {
        return new ArrayList<Object>();
    }
    if (collectionType.isAssignableFrom(ArrayList.class)) {
        return new ArrayList<Object>();
    }
    if (collectionType.isAssignableFrom(LinkedHashSet.class)) {
        return new LinkedHashSet<Object>();
    }
    if (collectionType.isAssignableFrom(TreeSet.class)) {
        return new TreeSet<Object>();
    }
    throw new UnsupportedOperationException(String.format("Cannot convert a Collection to type %s.", collectionType.getName()));
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
private static Object convertCollectionInternal(Class<?> collectionClass, Type targetElementType, Iterable<?> sourceObject, ViewDecoration decoration, ViewGraphDetails graphDetails) {
    Collection<Object> convertedElements = COLLECTION_MAPPER.createEmptyCollection(collectionClass);
    convertCollectionInternal(convertedElements, targetElementType, sourceObject, decoration, graphDetails);
    if (collectionClass.equals(DomainObjectSet.class)) {
        return new ImmutableDomainObjectSet(convertedElements);
    } else {
        return convertedElements;
    }
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public DefaultProjectOutcomes(String name, String projectPath, String description, File projectDirectory,
                              DomainObjectSet<? extends GradleBuildOutcome> outcomes, ProjectOutcomes parent) {
    this.name = name;
    this.projectPath = projectPath;
    this.description = description;
    this.projectDirectory = projectDirectory;
    this.outcomes = outcomes;
    this.parent = parent;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@NotNull
private static Collection<File> copy(@Nullable DomainObjectSet<? extends IdeaSourceDirectory> directories) {
  if (directories == null) {
    return Collections.emptySet();
  }
  Set<File> paths = Sets.newHashSet();
  for (IdeaSourceDirectory directory : directories) {
    paths.add(directory.getDirectory());
  }
  return paths;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public void testGetGradleBuildFileFromModuleWithGradleFacet() {
  GradleProject project = createMock(GradleProject.class);
  expect(project.getPath()).andReturn(myModule.getName());

  //noinspection unchecked
  DomainObjectSet<? extends GradleTask> tasks = createMock(DomainObjectSet.class);
  project.getTasks();
  expectLastCall().andReturn(tasks);

  expect(tasks.isEmpty()).andReturn(true);
  replay(project, tasks);

  IdeaGradleProject gradleProject = IdeaGradleProject.newIdeaGradleProject(myModule.getName(), project, myBuildFile, "2.2.1");

  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    AndroidGradleFacet facet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    model.addFacet(facet);
    facet.setGradleProject(gradleProject);
  }
  finally {
    model.commit();
  }

  VirtualFile buildFile = GradleUtil.getGradleBuildFile(myModule);
  assertIsGradleBuildFile(buildFile);

  verify(project, tasks);
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@Test
public void testDefaultWarModel() throws Exception {
  DomainObjectSet<? extends IdeaModule> ideaModules = allModels.getIdeaProject().getModules();

  List<WebConfiguration> ideaModule = ContainerUtil.mapNotNull(ideaModules, new Function<IdeaModule, WebConfiguration>() {
    @Override
    public WebConfiguration fun(IdeaModule module) {
      return allModels.getExtraProject(module, WebConfiguration.class);
    }
  });

  assertEquals(1, ideaModule.size());
  WebConfiguration webConfiguration = ideaModule.get(0);
  assertEquals(1, webConfiguration.getWarModels().size());

  final WarModel warModel = webConfiguration.getWarModels().iterator().next();
  assertEquals("src/main/webapp", warModel.getWebAppDirName());

  assertArrayEquals(
    new String[]{"MANIFEST.MF", "additionalWebInf", "rootContent"},
    ContainerUtil.map2Array(warModel.getWebResources(), new Function<WebResource, Object>() {
      @Override
      public String fun(WebResource resource) {
        return resource.getFile().getName();
      }
    }));
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
private Collection<? extends String> getAllPaths(DomainObjectSet<? extends IdeaSourceDirectory> directories, final String moduleName) {
  List<String> list = ContainerUtil.map2List(directories, new Function<IdeaSourceDirectory, String>() {
    @Override
    public String fun(IdeaSourceDirectory sourceDirectory) {
      String path =
        FileUtil.toCanonicalPath(FileUtil.getRelativePath(new File(testDir, moduleName), sourceDirectory.getDirectory()));
      Assert.assertNotNull(path);
      return path.substring(path.indexOf("/") + 1);
    }
  });
  Collections.sort(list);
  return list;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@NotNull
private static List<IdeaSingleEntryLibraryDependency> findLocalLibraries(
  @NotNull final DomainObjectSet<? extends IdeaDependency> dependencies, @NotNull final String scope) {
  return ContainerUtil.mapNotNull(
    dependencies,
    new Function<IdeaDependency, IdeaSingleEntryLibraryDependency>() {
      @Override
      public IdeaSingleEntryLibraryDependency fun(IdeaDependency dependency) {
        return dependency instanceof IdeaSingleEntryLibraryDependency &&
               scope.equals(dependency.getScope().getScope().toLowerCase(Locale.ENGLISH))
               ? (IdeaSingleEntryLibraryDependency)dependency : null;
      }
    }
  );
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@Override
public DomainObjectSet<? extends IdeaSourceDirectory> getGeneratedSourceDirectories() {
  List<IdeaSourceDirectory> generatedSourceDirectories = new ArrayList<IdeaSourceDirectory>();
  for (IdeaSourceDirectory sourceDirectory : mySourceDirectories) {
    if(sourceDirectory.isGenerated()) {
      generatedSourceDirectories.add(sourceDirectory);
    }
  }
  return ImmutableDomainObjectSet.of(generatedSourceDirectories);
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@Override
public DomainObjectSet<? extends IdeaSourceDirectory> getGeneratedTestDirectories() {
  List<IdeaSourceDirectory> generatedTestDirectories = new ArrayList<IdeaSourceDirectory>();
  for (IdeaSourceDirectory sourceDirectory : myTestDirectories) {
    if(sourceDirectory.isGenerated()) {
      generatedTestDirectories.add(sourceDirectory);
    }
  }
  return ImmutableDomainObjectSet.of(generatedTestDirectories);
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public void execute(ProjectConfigurationProvider provider, BasicGradleProject parent) throws Exception {
	DomainObjectSet<? extends BasicGradleProject> subprojects = null;
	File parentDir = provider.getConfigurationFile().getCanonicalFile().getParentFile();

	if (parent == null) {
		GradleConnector connector = GradleConnector.newConnector();

		connector.forProjectDirectory(parentDir);
		ProjectConnection connection = connector.connect();

		GradleBuild settings = connection.getModel(GradleBuild.class);
		subprojects = settings.getProjects();
	} else {
		subprojects = parent.getChildren();
	}
	Iterator<? extends BasicGradleProject> it = subprojects.iterator();
	String currentDir = parentDir.getCanonicalPath();
	List<String> modules = new LinkedList<String>();
	while (it.hasNext()) {
		BasicGradleProject current = it.next();
		File projectDir = current.getProjectDirectory().getCanonicalFile();
		if (!projectDir.getPath().equals(currentDir)) {
			modules.add(current.getName());
			ProjectConfigurationProvider moduleCfgProvider = provider
					.clone(new File(projectDir, "walkmod." + provider.getFileExtension()));

			execute(moduleCfgProvider, current);
		}

	}
	if (!modules.isEmpty()) {
		provider.addModules(modules);
	} else {
		provider.createConfig();
	}
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
@NotNull
private static Map<String, Pair<DataNode<ModuleData>, IdeaModule>> createModules(
  @NotNull IdeaProject gradleProject,
  @NotNull DataNode<ProjectData> ideProject) throws IllegalStateException
{

  DomainObjectSet<? extends IdeaModule> gradleModules = gradleProject.getModules();
  if (gradleModules == null || gradleModules.isEmpty()) {
    throw new IllegalStateException("No modules found for the target project: " + gradleProject);
  }
  Map<String, Pair<DataNode<ModuleData>, IdeaModule>> result = ContainerUtilRt.newHashMap();
  for (IdeaModule gradleModule : gradleModules) {
    if (gradleModule == null) {
      continue;
    }
    String moduleName = gradleModule.getName();
    if (moduleName == null) {
      throw new IllegalStateException("Module with undefined name detected: " + gradleModule);
    }
    ProjectData projectData = ideProject.getData();
    String moduleConfigPath
      = GradleUtil.getConfigPath(gradleModule.getGradleProject(), ideProject.getData().getLinkedExternalProjectPath());
    ModuleData ideModule = new ModuleData(GradleConstants.SYSTEM_ID,
                                          StdModuleTypes.JAVA.getId(),
                                          moduleName,
                                          projectData.getIdeProjectFileDirectoryPath(),
                                          moduleConfigPath);
    Pair<DataNode<ModuleData>, IdeaModule> previouslyParsedModule = result.get(moduleName);
    if (previouslyParsedModule != null) {
      throw new IllegalStateException(
        String.format("Modules with duplicate name (%s) detected: '%s' and '%s'", moduleName, ideModule, previouslyParsedModule)
      );
    }
    DataNode<ModuleData> moduleDataNode = ideProject.createChild(ProjectKeys.MODULE, ideModule);
    result.put(moduleName, new Pair<DataNode<ModuleData>, IdeaModule>(moduleDataNode, gradleModule));
  }
  return result;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
/**
 * Populates {@link ProjectKeys#CONTENT_ROOT) content roots} of the given ide module on the basis of the information
 * contained at the given gradle module.
 *
 * @param gradleModule    holder of the module information received from the gradle tooling api
 * @param ideModule       corresponding module from intellij gradle plugin domain
 * @throws IllegalArgumentException   if given gradle module contains invalid data
 */
private static void populateContentRoots(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule)
  throws IllegalArgumentException
{
  DomainObjectSet<? extends IdeaContentRoot> 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());
    Set<File> excluded = gradleContentRoot.getExcludeDirectories();
    if (excluded != null) {
      for (File file : excluded) {
        ideContentRoot.storePath(ExternalSystemSourceType.EXCLUDED, file.getAbsolutePath());
      }
    }
    ideModule.createChild(ProjectKeys.CONTENT_ROOT, ideContentRoot);
  }
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
private boolean isEclipseSupported(ProjectEntry entry) {
    EclipseProject model = entry.getModel();
    DomainObjectSet<? extends GradleTask> tasks = model.getGradleProject().getTasks();
    for (GradleTask task : tasks) {
        if (task.getName().equals(GradleBuildTask.TASK_CONFIGURE_ECLIPSE)) {
            return true;
        }
    }
    return false;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public DomainObjectSet<? extends GradleBuild> getIncludedBuilds() {
    return ImmutableDomainObjectSet.of(Collections.<GradleBuild>emptyList());
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
private DomainObjectSet<GradleFileBuildOutcome> getFileOutcomes(Project project) {
    List<GradleFileBuildOutcome> fileBuildOutcomes = Lists.newArrayList();
    addArtifacts(project, fileBuildOutcomes);
    return new ImmutableDomainObjectSet<GradleFileBuildOutcome>(fileBuildOutcomes);
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public DomainObjectSet<? extends GradleBuildOutcome> getOutcomes() {
    return outcomes;
}
 

import org.gradle.tooling.model.DomainObjectSet; //导入依赖的package包/类
public DomainObjectSet<ProjectOutcomes> getChildren() {
    return new ImmutableDomainObjectSet<ProjectOutcomes>(children);
}