Java GradleProject类代码示例

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
private List<ConsumerProvidedTaskSelector> buildRecursively(GradleProject project) {
    Multimap<String, String> aggregatedTasks = ArrayListMultimap.create();

    collectTasks(project, aggregatedTasks);

    List<ConsumerProvidedTaskSelector> selectors = Lists.newArrayList();
    for (String selectorName : aggregatedTasks.keySet()) {
        SortedSet<String> selectorTasks = Sets.newTreeSet(new TaskNameComparator());
        selectorTasks.addAll(aggregatedTasks.get(selectorName));
        selectors.add(new ConsumerProvidedTaskSelector().
                setName(selectorName).
                setTaskNames(selectorTasks).
                setDescription(project.getParent() != null
                        ? String.format("%s:%s task selector", project.getPath(), selectorName)
                        : String.format("%s task selector", selectorName)).
                setDisplayName(String.format("%s in %s and subprojects.", selectorName, project.getName())));
    }
    return selectors;
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的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.GradleProject; //导入依赖的package包/类
private List<BasicGradleTaskSelector> buildRecursively(GradleProject project) {
    Multimap<String, String> aggregatedTasks = ArrayListMultimap.create();
    for (GradleProject childProject : project.getChildren()) {
        List<BasicGradleTaskSelector> childSelectors = buildRecursively(childProject);
        for (BasicGradleTaskSelector childSelector : childSelectors) {
            aggregatedTasks.putAll(childSelector.getName(), childSelector.getTaskNames());
        }
    }
    for (GradleTask task : project.getTasks()) {
        aggregatedTasks.put(task.getName(), task.getPath());
    }
    List<BasicGradleTaskSelector> selectors = Lists.newArrayList();
    for (String selectorName : aggregatedTasks.keySet()) {
        SortedSet<String> selectorTasks = Sets.newTreeSet(new TaskNameComparator());
        selectorTasks.addAll(aggregatedTasks.get(selectorName));
        selectors.add(new BasicGradleTaskSelector().
                setName(selectorName).
                setTaskNames(selectorTasks).
                setDescription(project.getParent() != null
                        ? String.format("%s:%s task selector", project.getPath(), selectorName)
                        : String.format("%s task selector", selectorName)).
                setDisplayName(String.format("%s in %s and subprojects.", selectorName, project.getName())));
    }
    return selectors;
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
private static void addModelVersions(Map<Class<?>, String> map) {
    map.put(HierarchicalEclipseProject.class, "1.0-milestone-3");
    map.put(EclipseProject.class, "1.0-milestone-3");
    map.put(IdeaProject.class, "1.0-milestone-5");
    map.put(GradleProject.class, "1.0-milestone-5");
    map.put(BasicIdeaProject.class, "1.0-milestone-5");
    map.put(BuildEnvironment.class, "1.0-milestone-8");
    map.put(ProjectOutcomes.class, "1.2");
    map.put(Void.class, "1.0-milestone-3");
    map.put(GradleBuild.class, "1.8");
    map.put(ProjectPublications.class, "1.12");
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
static void addModelToProtocolMappings(Map<Class<?>, Class<?>> map) {
    map.put(HierarchicalEclipseProject.class, HierarchicalEclipseProjectVersion1.class);
    map.put(EclipseProject.class, EclipseProjectVersion3.class);
    map.put(IdeaProject.class, InternalIdeaProject.class);
    map.put(GradleProject.class, InternalGradleProject.class);
    map.put(BasicIdeaProject.class, InternalBasicIdeaProject.class);
    map.put(BuildEnvironment.class, InternalBuildEnvironment.class);
    map.put(ProjectOutcomes.class, InternalProjectOutcomes.class);
    map.put(Void.class, Void.class);
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
static void addModelNameMappings(Map<Class<?>, String> map) {
    map.put(HierarchicalEclipseProject.class, "org.gradle.tooling.model.eclipse.HierarchicalEclipseProject");
    map.put(EclipseProject.class, "org.gradle.tooling.model.eclipse.EclipseProject");
    map.put(IdeaProject.class, "org.gradle.tooling.model.idea.IdeaProject");
    map.put(GradleProject.class, "org.gradle.tooling.model.GradleProject");
    map.put(BasicIdeaProject.class, "org.gradle.tooling.model.idea.BasicIdeaProject");
    map.put(BuildEnvironment.class, "org.gradle.tooling.model.build.BuildEnvironment");
    map.put(ProjectOutcomes.class, "org.gradle.tooling.model.outcomes.ProjectOutcomes");
    map.put(Void.class, Void.class.getName());
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
@Override
public boolean maySupportModel(Class<?> modelType) {
    return modelType.equals(ProjectOutcomes.class)
        || modelType.equals(HierarchicalEclipseProject.class)
        || modelType.equals(EclipseProject.class)
        || modelType.equals(IdeaProject.class)
        || modelType.equals(BasicIdeaProject.class)
        || modelType.equals(BuildEnvironment.class)
        || modelType.equals(GradleProject.class)
        || modelType.equals(Void.class);
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
public <T> T produceModel(Class<T> type, ConsumerOperationParameters operationParameters) {
    if (type.equals(BuildInvocations.class)) {
        if (!versionDetails.maySupportModel(GradleProject.class)) {
            throw Exceptions.unsupportedModel(type, versionDetails.getVersion());
        }
        GradleProject gradleProject = delegate.produceModel(GradleProject.class, operationParameters);
        return adapter.adapt(type, new BuildInvocationsConverter().convert(gradleProject));
    }
    return delegate.produceModel(type, operationParameters);
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
@Override
public <T> T getModel(Model target, Class<T> modelType) throws UnknownModelException {
    if (modelType.equals(BuildInvocations.class)) {
        GradleProject gradleProject = delegate.getModel(target, GradleProject.class);
        return adapter.adapt(modelType, new BuildInvocationsConverter().convert(gradleProject));
    }
    return delegate.getModel(target, modelType);
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
public <T> T produceModel(Class<T> type, ConsumerOperationParameters operationParameters) {
    if (type.equals(GradleBuild.class)) {
        GradleProject gradleProject = delegate.produceModel(GradleProject.class, operationParameters);
        final DefaultGradleBuild convert = new GradleBuildConverter().convert(gradleProject);
        return mappingProvider.applyCompatibilityMapping(adapter.builder(type), operationParameters).build(convert);
    }
    return delegate.produceModel(type, operationParameters);
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
public <T> ViewBuilder<T> applyCompatibilityMapping(ViewBuilder<T> viewBuilder, DefaultProjectIdentifier projectIdentifier) {
    viewBuilder.mixInTo(GradleProject.class, new GradleProjectIdentifierMixin(projectIdentifier.getBuildIdentifier()));
    viewBuilder.mixInTo(BasicGradleProject.class, new BasicGradleProjectIdentifierMixin(projectIdentifier.getBuildIdentifier()));
    FixedBuildIdentifierProvider identifierProvider = new FixedBuildIdentifierProvider(projectIdentifier);
    identifierProvider.applyTo(viewBuilder);
    viewBuilder.mixInTo(GradleTask.class, TaskDisplayNameMixin.class);
    viewBuilder.mixInTo(IdeaProject.class, IdeaProjectJavaLanguageSettingsMixin.class);
    viewBuilder.mixInTo(IdeaDependency.class, IdeaModuleDependencyTargetNameMixin.class);
    viewBuilder.mixInTo(GradleBuild.class, new IncludedBuildsMixin());
    return viewBuilder;
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
private void collectTasks(GradleProject project, Multimap<String, String> aggregatedTasks) {
    for (GradleProject childProject : project.getChildren()) {
        collectTasks(childProject, aggregatedTasks);
    }
    for (GradleTask task : project.getTasks()) {
        aggregatedTasks.put(task.getName(), task.getPath());
    }
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
public DefaultGradleBuild convert(GradleProject project) {
    DefaultGradleBuild gradleBuild = new DefaultGradleBuild();
    PartialBasicGradleProject rootProject = toPartialGradleProject(project);
    gradleBuild.setRootProject(rootProject);
    gradleBuild.addProject(rootProject);
    convertChildren(gradleBuild, rootProject, project);
    return gradleBuild;
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
private void convertChildren(DefaultGradleBuild gradleBuild, PartialBasicGradleProject rootProject, GradleProject project) {
    final List<? extends GradleProject> childProjects = new ArrayList<GradleProject>(project.getChildren());
    Collections.sort(childProjects, new Comparator<GradleProject>() {
        public int compare(GradleProject gp1, GradleProject gp2) {
            return gp1.getName().compareTo(gp2.getName());
        }
    });
    for (GradleProject childProject : childProjects) {
        PartialBasicGradleProject basicGradleProject = toPartialGradleProject(childProject);
        gradleBuild.addProject(basicGradleProject);
        basicGradleProject.setParent(rootProject);
        rootProject.addChild(basicGradleProject);
        convertChildren(gradleBuild, basicGradleProject, childProject);
    }
}
 

import org.gradle.tooling.model.GradleProject; //导入依赖的package包/类
private PartialBasicGradleProject toPartialGradleProject(GradleProject childProject) {
    PartialBasicGradleProject basicGradleProject = new PartialBasicGradleProject();
    basicGradleProject.setName(childProject.getName());
    ProjectIdentifier id = childProject.getProjectIdentifier();
    basicGradleProject.setProjectIdentifier(new DefaultProjectIdentifier(id.getBuildIdentifier().getRootDir(), id.getProjectPath()));
    return basicGradleProject;
}