Java ModelMap.create方法代码示例

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@ComponentBinaries
public void createBinaries(ModelMap<JarBinarySpec> binaries, PlatformResolvers platforms, final JvmLibrarySpecInternal jvmLibrary) {
    List<JavaPlatform> selectedPlatforms = resolvePlatforms(platforms, jvmLibrary);
    final Set<String> exportedPackages = exportedPackagesOf(jvmLibrary);
    final Collection<DependencySpec> apiDependencies = apiDependenciesOf(jvmLibrary);
    final Collection<DependencySpec> dependencies = componentDependenciesOf(jvmLibrary);
    for (final JavaPlatform platform : selectedPlatforms) {
        final BinaryNamingScheme namingScheme = namingSchemeFor(jvmLibrary, selectedPlatforms, platform);
        binaries.create(namingScheme.getBinaryName(), new Action<JarBinarySpec>() {
            @Override
            public void execute(JarBinarySpec jarBinarySpec) {
                JarBinarySpecInternal jarBinary = (JarBinarySpecInternal) jarBinarySpec;
                jarBinary.setNamingScheme(namingScheme);
                jarBinary.setTargetPlatform(platform);
                jarBinary.setExportedPackages(exportedPackages);
                jarBinary.setApiDependencies(apiDependencies);
                jarBinary.setDependencies(dependencies);
            }
        });
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
private void createPublishTasksForEachMavenRepo(ModelMap<Task> tasks, PublishingExtension extension, final Task publishLifecycleTask, final MavenPublicationInternal publication,
                                                final String publicationName) {
    for (final MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) {
        final String repositoryName = repository.getName();

        String publishTaskName = "publish" + capitalize(publicationName) + "PublicationTo" + capitalize(repositoryName) + "Repository";

        tasks.create(publishTaskName, PublishToMavenRepository.class, new Action<PublishToMavenRepository>() {
            public void execute(PublishToMavenRepository publishTask) {
                publishTask.setPublication(publication);
                publishTask.setRepository(repository);
                publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
                publishTask.setDescription("Publishes Maven publication '" + publicationName + "' to Maven repository '" + repositoryName + "'.");

            }
        });
        publishLifecycleTask.dependsOn(publishTaskName);
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
public static void createBuildDependentComponentsTasks(ModelMap<Task> tasks, ComponentSpecContainer components) {
    for (final VariantComponentSpec component : components.withType(NativeComponentSpec.class).withType(VariantComponentSpec.class)) {
        tasks.create(getAssembleDependentComponentsTaskName(component), DefaultTask.class, new Action<DefaultTask>() {
            @Override
            public void execute(DefaultTask assembleDependents) {
                assembleDependents.setGroup("Build Dependents");
                assembleDependents.setDescription("Assemble dependents of " + component.getDisplayName() + ".");
            }
        });
        tasks.create(getBuildDependentComponentsTaskName(component), DefaultTask.class, new Action<DefaultTask>() {
            @Override
            public void execute(DefaultTask buildDependents) {
                buildDependents.setGroup("Build Dependents");
                buildDependents.setDescription("Build dependents of " + component.getDisplayName() + ".");
            }
        });
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@BinaryTasks
public void sharedLibraryTasks(ModelMap<Task> tasks, final SharedLibraryBinarySpecInternal binary) {
    String taskName = binary.getNamingScheme().getTaskName("link");
    tasks.create(taskName, LinkSharedLibrary.class, new Action<LinkSharedLibrary>() {
        @Override
        public void execute(LinkSharedLibrary linkTask) {
            linkTask.setDescription("Links " + binary.getDisplayName());
            linkTask.setToolChain(binary.getToolChain());
            linkTask.setTargetPlatform(binary.getTargetPlatform());
            linkTask.setOutputFile(binary.getSharedLibraryFile());
            linkTask.setInstallName(binary.getSharedLibraryFile().getName());
            linkTask.setLinkerArgs(binary.getLinker().getArgs());

            linkTask.lib(new NativeComponents.BinaryLibs(binary) {
                @Override
                protected FileCollection getFiles(NativeDependencySet nativeDependencySet) {
                    return nativeDependencySet.getLinkFiles();
                }
            });
        }
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Create debug tasks
 *
 * @param tasks Task container to create new tasks
 * @param config Project configuration
 * @param project Current project identifier
 */
@Mutate
public void createDebugTasks(ModelMap<Task> tasks, ProjectConfig config, ProjectIdentifier project) {
    // Create debug task to dump dependencies
    if (config.isEnableDebugTasks()) {
        tasks.create("debugDependencies", Task.class, tt -> {
            tt.doLast(t -> {
                PrintStream out = System.out;
                out.print("Project: ");
                out.println(project.getName());

                for (Configuration configuration : t.getProject().getConfigurations()) {
                    out.print("  Configuration: ");
                    out.println(configuration.getName());

                    for (Dependency dependency : configuration.getDependencies()) {
                        out.print("    Dependency: ");
                        out.println(formatDependency(dependency));
                    }
                }
            });
        });
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Create Eclipse annotations tasks
 *
 * @param tasks Task container
 * @param configurations Container to access configurations
 * @param buildDir Build directory
 */
@Mutate
public void createEclipseAnnotationsTasks(ModelMap<Task> tasks, ConfigurationContainer configurations,
        @Path("buildDir") File buildDir) {
    tasks.create("eclipseAnnotations", EclipseAnnotationsTask.class, t -> {
        t.setDescription("Generates external nullability annotations for dependencies.");
        t.setGroup("IDE");

        ConventionMapping parameters = t.getConventionMapping();
        parameters.map("jars", () -> {
            Set<File> jars = configurations.stream()
                    .filter(c -> c.isCanBeResolved()
                            && !c.getName().equals(JavaConfigPlugin.ANNOTATIONS_CONFIGURATION))
                    .map(c -> c.getResolvedConfiguration().getLenientConfiguration())
                    .flatMap(c -> c.getArtifacts().stream().filter(
                            a -> !(a.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier)
                                    && a.getType().equals("jar"))
                            .map(a -> a.getFile()))
                    .collect(Collectors.toSet());

            return jars;
        });
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@ComponentBinaries
public void createBinaries(
        final ModelMap<AndroidBinary> binaries,
        @Path("android") final AndroidConfig androidConfig,
        @Path("android.buildTypes") final ModelMap<BuildType> buildTypes,
        final List<ProductFlavorCombo<ProductFlavor>> flavorCombos,
        final AndroidComponentSpec spec) {
    if (flavorCombos.isEmpty()) {
        flavorCombos.add(new ProductFlavorCombo<ProductFlavor>());
    }

    for (final BuildType buildType : buildTypes.values()) {
        for (final ProductFlavorCombo<ProductFlavor> flavorCombo : flavorCombos) {
            binaries.create(getBinaryName(buildType, flavorCombo),
                    new Action<AndroidBinary>() {
                        @Override
                        public void execute(AndroidBinary androidBinary) {
                            DefaultAndroidBinary binary = (DefaultAndroidBinary) androidBinary;
                            binary.setBuildType(buildType);
                            binary.setProductFlavors(flavorCombo.getFlavorList());
                        }
                    });
        }
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
public static void createStlCopyTask(NdkHandler ndkHandler, String stl,
        ModelMap<Task> tasks, final File buildDir,
        final SharedLibraryBinarySpec binary) {
    if (stl.endsWith("_shared")) {
        final StlNativeToolSpecification stlConfig = new StlNativeToolSpecification(ndkHandler,
                stl, binary.getTargetPlatform());

        String copyTaskName = NdkNamingScheme.getTaskName(binary, "copy", "StlSo");
        tasks.create(copyTaskName, Copy.class, new Action<Copy>() {
            @Override
            public void execute(Copy copy) {
                copy.from(stlConfig.getStlLib(binary.getTargetPlatform().getName()));
                copy.into(new File(buildDir, NdkNamingScheme.getOutputDirectoryName(binary)));

            }
        });
        binary.getBuildTask().dependsOn(copyTaskName);
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@BinaryTasks
public void copyGracljTools(ModelMap<Task> tasks, JUnitTestSuiteBinarySpec binary, GracljInternal internal) {
    Test testTask = binary.getTasks().getRun();

    // Need to provide explicit list of directories to scan for test namespaces in. Not sure it should be in this rule.
    JvmAssembly assembly = ((WithJvmAssembly) binary).getAssembly();
    Stream<File> classDirs = assembly.getClassDirectories().stream();
    Stream<File> resourceDirs = assembly.getResourceDirectories().stream();
    String testDirs = Stream.concat(classDirs, resourceDirs)
        .map(File::getAbsolutePath)
        .collect(Collectors.joining(File.pathSeparator));
    testTask.systemProperty("clojure.test.dirs", testDirs);

    tasks.create(binary.getName() + "GracljTools", Copy.class, task -> {
        testTask.dependsOn(task);
        File tools = internal.resolve("org.graclj:graclj-tools:" + internal.getGracljVersion() + "@jar").getSingleFile();
        task.from(task.getProject().zipTree(tools));
        task.into(binary.getClassesDir());
    });
    testTask.setClasspath(testTask.getClasspath().plus(internal.resolve("org.graclj:graclj-tools:" + internal.getGracljVersion())));
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
/**
 * Finalize the wsimport components
 *
 * @param wsimportComponents Wsimport components to finalize
 * @param files File operations
 */
@Finalize
public void createWsdlSourceSets(ModelMap<WsimportComponent> wsimportComponents, FileOperations files) {
    for (String componentName : DEFAULT_SOURCE_SET_NAMES) {
        File sourceDirectory = getSourceDirectory(componentName, "wsdl");
        String wsdlComponentName = getWsdlComponentName(componentName);

        wsimportComponents.create(wsdlComponentName, c -> {
            if (files.file(sourceDirectory).isDirectory()) {
                c.getSources().create("wsdl", WsdlSourceSet.class, s -> {
                    s.getSource().setSrcDirs(Collections.singleton(sourceDirectory));
                });
            }
        });
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
private static <S extends NativeTestSuiteBinarySpec> void createNativeTestSuiteBinary(ModelMap<S> binaries,
                                                NativeTestSuiteSpec testSuite,
                                                Class<S> testSuiteBinaryClass,
                                                String typeString,
                                                final NativeBinarySpec testedBinary,
                                                final File buildDir, ServiceRegistry serviceRegistry) {

    final BinaryNamingScheme namingScheme = namingSchemeFor(testSuite, (NativeBinarySpecInternal) testedBinary, typeString);
    final NativeDependencyResolver resolver = serviceRegistry.get(NativeDependencyResolver.class);

    binaries.create(namingScheme.getBinaryName(), testSuiteBinaryClass, new Action<S>() {
        @Override
        public void execute(S binary) {
            final NativeTestSuiteBinarySpecInternal testBinary = (NativeTestSuiteBinarySpecInternal) binary;
            testBinary.setTestedBinary((NativeBinarySpecInternal) testedBinary);
            testBinary.setNamingScheme(namingScheme);
            testBinary.setResolver(resolver);
            testBinary.setToolChain(testedBinary.getToolChain());
            NativeExecutableFileSpec executable = testBinary.getExecutable();
            NativeInstallationSpec installation = testBinary.getInstallation();
            executable.setToolChain(testedBinary.getToolChain());
            executable.setFile(executableFileFor(testBinary, buildDir));
            installation.setDirectory(installationDirFor(testBinary, buildDir));
            NativeComponents.createInstallTask(testBinary, installation, executable, namingScheme);
            NativeComponents.createExecutableTask(testBinary, testBinary.getExecutableFile());
            createRunTask(testBinary, namingScheme.getTaskName("run"));
        }
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@Model
@Hidden
public void javaToolChains(ModelMap<LocalJavaInstallation> javaInstallations, final JavaInstallationProbe probe) {
    javaInstallations.create("currentGradleJDK", InstalledJdk.class, new Action<InstalledJdk>() {
        @Override
        public void execute(InstalledJdk installedJdk) {
            installedJdk.setJavaHome(Jvm.current().getJavaHome());
            probe.current(installedJdk);
        }
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@Defaults
public void resolveJavaToolChains(final ModelMap<LocalJavaInstallation> installedJdks, ModelMap<LocalJava> localJavaInstalls, final JavaInstallationProbe probe) {
    File currentJavaHome = canonicalFile(Jvm.current().getJavaHome());
    // TODO:Cedric The following validation should in theory happen in its own rule, but it is not possible now because
    // there's no way to iterate on the map as subject of a `@Validate` rule without Gradle thinking you're trying to mutate it
    validateNoDuplicate(localJavaInstalls);
    for (final LocalJava candidate : localJavaInstalls) {
        final File javaHome = canonicalFile(candidate.getPath());
        final JavaInstallationProbe.ProbeResult probeResult = probe.checkJdk(javaHome);
        Class<? extends LocalJavaInstallation> clazz;
        switch (probeResult.getInstallType()) {
            case IS_JDK:
                clazz = InstalledJdkInternal.class;
                break;
            case IS_JRE:
                clazz = InstalledJre.class;
                break;
            case NO_SUCH_DIRECTORY:
                throw new InvalidModelException(String.format("Path to JDK '%s' doesn't exist: %s", candidate.getName(), javaHome));
            case INVALID_JDK:
            default:
                throw new InvalidModelException(String.format("JDK '%s' is not a valid JDK installation: %s\n%s", candidate.getName(), javaHome, probeResult.getError()));
        }

        if (!javaHome.equals(currentJavaHome)) {
            installedJdks.create(candidate.getName(), clazz, new Action<LocalJavaInstallation>() {
                @Override
                public void execute(LocalJavaInstallation installedJdk) {
                    installedJdk.setJavaHome(javaHome);
                    probeResult.configure(installedJdk);
                }
            });
        }
    }
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
@BinaryTasks
public void createTasks(ModelMap<Task> tasks, final JarBinarySpecInternal binary, final @Path("buildDir") File buildDir) {
    final File runtimeJarDestDir = binary.getJarFile().getParentFile();
    final String runtimeJarArchiveName = binary.getJarFile().getName();
    final String createRuntimeJar = "create" + capitalize(binary.getProjectScopedName());
    final JvmAssembly assembly = binary.getAssembly();
    final JarFile runtimeJarFile = binary.getRuntimeJar();
    tasks.create(createRuntimeJar, Jar.class, new Action<Jar>() {
        @Override
        public void execute(Jar jar) {
            jar.setDescription("Creates the binary file for " + binary + ".");
            jar.from(assembly.getClassDirectories());
            jar.from(assembly.getResourceDirectories());
            jar.setDestinationDir(runtimeJarDestDir);
            jar.setArchiveName(runtimeJarArchiveName);
            jar.dependsOn(assembly);
            runtimeJarFile.setBuildTask(jar);
        }
    });

    final JarFile apiJarFile = binary.getApiJar();
    final Set<String> exportedPackages = binary.getExportedPackages();
    String apiJarTaskName = apiJarTaskName(binary);
    tasks.create(apiJarTaskName, ApiJar.class, new Action<ApiJar>() {
        @Override
        public void execute(ApiJar apiJarTask) {
            apiJarTask.setDescription("Creates the API binary file for " + binary + ".");
            apiJarTask.setOutputFile(apiJarFile.getFile());
            apiJarTask.setExportedPackages(exportedPackages);
            configureApiJarInputs(apiJarTask, assembly);
            apiJarTask.dependsOn(assembly);
            apiJarFile.setBuildTask(apiJarTask);
        }
    });
}
 

import org.gradle.model.ModelMap; //导入方法依赖的package包/类
private void createLocalInstallTask(ModelMap<Task> tasks, final Task publishLocalLifecycleTask, final MavenPublicationInternal publication, final String publicationName) {
    final String installTaskName = "publish" + capitalize(publicationName) + "PublicationToMavenLocal";

    tasks.create(installTaskName, PublishToMavenLocal.class, new Action<PublishToMavenLocal>() {
        public void execute(PublishToMavenLocal publishLocalTask) {
            publishLocalTask.setPublication(publication);
            publishLocalTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
            publishLocalTask.setDescription("Publishes Maven publication '" + publicationName + "' to the local Maven repository.");
        }
    });
    publishLocalLifecycleTask.dependsOn(installTaskName);
}