Java JvmLibrarySpec类代码示例

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void createJarBinarySpecLocalComponentMetaData(EnumMap<UsageKind, List<PublishArtifact>> artifacts, JarBinarySpecInternal jarBinarySpec, EnumMap<UsageKind, Iterable<DependencySpec>> dependenciesPerUsage, boolean toAssembly) {
    JarFile apiJar = jarBinarySpec.getApiJar();
    configureUsageMetadata(UsageKind.API,
        jarBinarySpec.getApiDependencies(),
        dependenciesPerUsage);

    JarFile runtimeJar = jarBinarySpec.getRuntimeJar();
    JvmLibrarySpec library = jarBinarySpec.getLibrary();
    configureUsageMetadata(UsageKind.RUNTIME,
        library != null ? collectDependencies(jarBinarySpec, library, library.getDependencies().getDependencies(), jarBinarySpec.getApiDependencies()) : Collections.<DependencySpec>emptyList(),
        dependenciesPerUsage);

    if (!toAssembly) {
        addArtifact(UsageKind.API, apiJar, artifacts);
        addArtifact(UsageKind.RUNTIME, runtimeJar, artifacts);
    }

}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public void execute(JvmLibrarySpec jvmLibrary) {
    List<String> targetPlatforms = jvmLibrary.getTargetPlatforms();
    // TODO:DAZ We should have a generic (JVM + Native) way to get the 'best' platform to build when no target is defined.
    // This logic needs to inspect the available platforms and find the closest one matching the current platform
    if (targetPlatforms.isEmpty()) {
        targetPlatforms = Collections.singletonList(new DefaultJavaPlatform(JavaVersion.current()).getName());
    }
    List<JavaPlatform> selectedPlatforms = platforms.select(JavaPlatform.class, targetPlatforms);
    for (JavaPlatform platform: selectedPlatforms) {
        JavaToolChain toolChain = toolChains.getForPlatform(platform);
        BinaryNamingSchemeBuilder componentBuilder = namingSchemeBuilder
                .withComponentName(jvmLibrary.getName())
                .withTypeString("jar");
        if (selectedPlatforms.size() > 1) { //Only add variant dimension for multiple jdk targets to avoid breaking the default naming scheme
            componentBuilder = componentBuilder.withVariantDimension(platform.getName());
        }
        BinaryNamingScheme namingScheme = componentBuilder.build(); //TODO freekh: move out?
        factory.createJarBinaries(jvmLibrary, namingScheme, toolChain, platform); //TODO: createJarBinaries is mutable! We should not be doing this - execute could return a list instead
    }
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public void apply(final Project project) {
    project.getPlugins().apply(ComponentModelBasePlugin.class);

    ComponentSpecContainer componentSpecs = project.getExtensions().getByType(ComponentSpecContainer.class);

    final ProjectSourceSet sources = project.getExtensions().getByType(ProjectSourceSet.class);
    componentSpecs.registerFactory(JvmLibrarySpec.class, new NamedDomainObjectFactory<JvmLibrarySpec>() {
        public JvmLibrarySpec create(String name) {
            ComponentSpecIdentifier id = new DefaultComponentSpecIdentifier(project.getPath(), name);
            return new DefaultJvmLibrarySpec(id, sources.maybeCreate(name));
        }
    });

    final NamedDomainObjectContainer<JvmLibrarySpec> jvmLibraries = componentSpecs.containerWithType(JvmLibrarySpec.class);
    project.getExtensions().create("jvm", DefaultJvmComponentExtension.class, jvmLibraries);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@Mutate
public void createBinaries(BinaryContainer binaries, PlatformContainer platforms, BinaryNamingSchemeBuilder namingSchemeBuilder,
                           NamedDomainObjectCollection<JvmLibrarySpec> libraries, @Path("buildDir") File buildDir, ServiceRegistry serviceRegistry, JavaToolChainRegistry toolChains) {
    Instantiator instantiator = serviceRegistry.get(Instantiator.class);

    List<Action<? super JarBinarySpec>> actions = Lists.newArrayList();
    actions.add(new JarBinarySpecInitializer(buildDir));
    actions.add(new MarkBinariesBuildable());
    Action<JarBinarySpec> initAction = Actions.composite(actions);
    JarBinariesFactory factory = new DefaultJarBinariesFactory(instantiator, initAction);

    Action<JvmLibrarySpec> createBinariesAction =
            new JvmLibrarySpecInitializer(factory, namingSchemeBuilder, toolChains, platforms);

    for (JvmLibrarySpec jvmLibrary : libraries) {
        createBinariesAction.execute(jvmLibrary);
        binaries.addAll(jvmLibrary.getBinaries());
    }
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@Override
public JvmLibrarySpec getLibrary() {
    return getComponentAs(JvmLibrarySpec.class);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@ComponentType
public void register(TypeBuilder<JvmLibrarySpec> builder) {
    builder.defaultImplementation(DefaultJvmLibrarySpec.class);
    builder.internalView(JvmLibrarySpecInternal.class);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
private BinaryNamingScheme namingSchemeFor(JvmLibrarySpec jvmLibrary, List<JavaPlatform> selectedPlatforms, JavaPlatform platform) {
    return DefaultBinaryNamingScheme.component(jvmLibrary.getName())
        .withBinaryType("Jar")
        .withRole("jar", true)
        .withVariantDimension(platform, selectedPlatforms);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public void createJarBinaries(JvmLibrarySpec jvmLibrary, BinaryNamingScheme namingScheme, JavaToolChain toolChain, JavaPlatform platform) {
    DefaultJarBinarySpec jarBinary = instantiator.newInstance(DefaultJarBinarySpec.class, jvmLibrary, namingScheme, toolChain, platform);
    setupDefaults(jarBinary);
    jarBinary.source(jvmLibrary.getSource());
    jvmLibrary.getBinaries().add(jarBinary);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public DefaultJarBinarySpec(JvmLibrarySpec library, BinaryNamingScheme namingScheme, JavaToolChain toolChain, JavaPlatform platform) {
    this.library = library;
    this.namingScheme = namingScheme;
    this.toolChain = toolChain;
    this.platform = platform;
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public JvmLibrarySpec getLibrary() {
    return library;
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public DefaultJvmComponentExtension(NamedDomainObjectContainer<JvmLibrarySpec> libraries) {
    this.libraries = libraries;
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public NamedDomainObjectContainer<JvmLibrarySpec> getLibraries() {
    return libraries;
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
public void libraries(Action<? super NamedDomainObjectContainer<? super JvmLibrarySpec>> action) {
    action.execute(libraries);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@Model
NamedDomainObjectCollection<JvmLibrarySpec> jvmLibraries(ComponentSpecContainer components) {
    return components.withType(JvmLibrarySpec.class);
}
 

import org.gradle.jvm.JvmLibrarySpec; //导入依赖的package包/类
@Defaults
public void addLibrarySourceSets(@Each JvmLibrarySpec component) {
    component.getSources().create("clojure", ClojureSourceSet.class);
}