org.gradle.api.artifacts.component.ComponentIdentifier Java Examples

public void resolve(DependencyMetaData dependency, ComponentIdentifier identifier, BuildableComponentResolveResult result) {
    resolver.resolve(dependency, identifier, result);

    if (result.getFailure() != null) {
        return;
    }
    if (dependency instanceof DslOriginDependencyMetaData) {
        ModuleDependency maybeClientModule = ((DslOriginDependencyMetaData) dependency).getSource();
        if (maybeClientModule instanceof ClientModule) {
            ClientModule clientModule = (ClientModule) maybeClientModule;

            MutableModuleComponentResolveMetaData clientModuleMetaData = ((MutableModuleComponentResolveMetaData)result.getMetaData()).copy();
            addClientModuleDependencies(clientModule, clientModuleMetaData);

            setClientModuleArtifact(clientModuleMetaData);

            result.setMetaData(clientModuleMetaData);
        }
    }
}
 

public void write(Encoder encoder, ComponentIdentifier value) throws IOException {
    if(value == null) {
        throw new IllegalArgumentException("Provided component identifier may not be null");
    }

    if(value instanceof DefaultModuleComponentIdentifier) {
        ModuleComponentIdentifier moduleComponentIdentifier = (ModuleComponentIdentifier)value;
        encoder.writeByte(Implementation.MODULE.getId());
        encoder.writeString(moduleComponentIdentifier.getGroup());
        encoder.writeString(moduleComponentIdentifier.getModule());
        encoder.writeString(moduleComponentIdentifier.getVersion());
    } else if(value instanceof DefaultProjectComponentIdentifier) {
        ProjectComponentIdentifier projectComponentIdentifier = (ProjectComponentIdentifier)value;
        encoder.writeByte(Implementation.BUILD.getId());
        encoder.writeString(projectComponentIdentifier.getProjectPath());
    } else {
        throw new IllegalArgumentException("Unsupported component identifier class: " + value.getClass());
    }
}
 

private static String format(ComponentIdentifier component, String message) {
    StringBuilder builder = new StringBuilder();
    builder.append("Could not determine artifacts for component '");
    builder.append(component.getDisplayName());
    builder.append("'");
    if (GUtil.isTrue(message)) {
        builder.append(": ");
        builder.append(message);
    }
    return builder.toString();
}
 

public ResolutionResultBuilder start(final ModuleVersionIdentifier root, final ComponentIdentifier componentIdentifier) {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(ROOT);
            moduleVersionIdentifierSerializer.write(encoder, root);
            componentIdentifierSerializer.write(encoder, componentIdentifier);
        }
    });
    return this;
}
 

public void resolve(DependencyMetaData dependency, ComponentIdentifier identifier, BuildableComponentResolveResult result) {
    if (!(identifier instanceof ModuleComponentIdentifier)) {
        throw new UnsupportedOperationException("Can resolve meta-data for module components only.");
    }

    // Force the requested version
    ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) identifier;
    dependency = dependency.withRequestedVersion(new DefaultModuleVersionSelector(moduleId.getGroup(), moduleId.getModule(), moduleId.getVersion()));

    metaDataResolver.resolve(dependency, result);
}
 

private static void handleSources(
        @NonNull Project project,
        @NonNull Set<ComponentIdentifier> artifacts,
        @NonNull Consumer<SyncIssue> failureConsumer) {
    final DependencyHandler dependencies = project.getDependencies();

    try {
        ArtifactResolutionQuery query = dependencies.createArtifactResolutionQuery();
        query.forComponents(artifacts);

        @SuppressWarnings("unchecked")
        Class<? extends Artifact>[] artifactTypesArray =
                (Class<? extends Artifact>[]) new Class<?>[] {SourcesArtifact.class};
        query.withArtifacts(JvmLibrary.class, artifactTypesArray);
        query.execute().getResolvedComponents();
    } catch (Throwable t) {
        DependencyFailureHandlerKt.processDependencyThrowable(
                t,
                s -> null,
                (data, messages) ->
                        failureConsumer.accept(
                                new SyncIssueImpl(
                                        SyncIssue.TYPE_GENERIC,
                                        SyncIssue.SEVERITY_WARNING,
                                        null,
                                        String.format(
                                                "Unable to download sources: %s",
                                                messages.get(0)),
                                        messages)));
    }
}
 

public ComponentIdentifier read(Decoder decoder) throws IOException {
    byte id = decoder.readByte();

    if(Implementation.BUILD.getId() == id) {
        return new DefaultProjectComponentIdentifier(decoder.readString());
    } else if(Implementation.MODULE.getId() == id) {
        return new DefaultModuleComponentIdentifier(decoder.readString(), decoder.readString(), decoder.readString());
    }

    throw new IllegalArgumentException("Unable to find component identifier with id: " + id);
}
 

public ComponentIdentifier read(Decoder decoder) throws IOException {
    byte id = decoder.readByte();

    if(Implementation.BUILD.getId() == id) {
        return new DefaultProjectComponentIdentifier(decoder.readString());
    } else if(Implementation.MODULE.getId() == id) {
        return new DefaultModuleComponentIdentifier(decoder.readString(), decoder.readString(), decoder.readString());
    }

    throw new IllegalArgumentException("Unable to find component identifier with id: " + id);
}
 

public ComponentIdentifier read(Decoder decoder) throws IOException {
    byte id = decoder.readByte();

    if(Implementation.BUILD.getId() == id) {
        return new DefaultProjectComponentIdentifier(decoder.readString());
    } else if(Implementation.MODULE.getId() == id) {
        return new DefaultModuleComponentIdentifier(decoder.readString(), decoder.readString(), decoder.readString());
    }

    throw new IllegalArgumentException("Unable to find component identifier with id: " + id);
}
 

public DefaultResolvedComponentResult(ModuleVersionIdentifier id, ComponentSelectionReason selectionReason, ComponentIdentifier componentId) {
    assert id != null;
    assert selectionReason != null;

    this.id = id;
    this.selectionReason = selectionReason;
    this.componentId = componentId;
}
 

public ComponentIdentifier createComponentIdentifier(ModuleInternal module) {
    String projectPath = module.getProjectPath();

    if(projectPath != null) {
        return new DefaultProjectComponentIdentifier(projectPath);
    }

    return new DefaultModuleComponentIdentifier(module.getGroup(), module.getName(), module.getVersion());
}
 

public ResolutionResultBuilder start(final ModuleVersionIdentifier root, final ComponentIdentifier componentIdentifier) {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(ROOT);
            moduleVersionIdentifierSerializer.write(encoder, root);
            componentIdentifierSerializer.write(encoder, componentIdentifier);
        }
    });
    return this;
}
 

public boolean matchesStrictly(ComponentIdentifier identifier) {
    assert identifier != null : "identifier cannot be null";

    if(identifier instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier moduleComponentIdentifier = (ModuleComponentIdentifier)identifier;
        return module.equals(moduleComponentIdentifier.getModule())
                && group.equals(moduleComponentIdentifier.getGroup())
                && version.equals(moduleComponentIdentifier.getVersion());
    }

    return false;
}
 

private boolean matchesSelected(ResolvedDependencyResult candidate) {
    ComponentIdentifier selected = candidate.getSelected().getId();

    if (moduleIdentifier != null && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
        return selectedModule.getGroup().equals(moduleIdentifier.getGroup())
                && selectedModule.getModule().equals(moduleIdentifier.getName());
    }

    return false;
}
 

public ComponentIdentifier createComponentIdentifier(ModuleInternal module) {
    String projectPath = module.getProjectPath();

    if(projectPath != null) {
        return new DefaultProjectComponentIdentifier(projectPath);
    }

    return new DefaultModuleComponentIdentifier(module.getGroup(), module.getName(), module.getVersion());
}
 

public Set<RenderableDependency> getChildren() {
    Map<ComponentIdentifier, RenderableDependency> children = new LinkedHashMap<ComponentIdentifier, RenderableDependency>();
    for (ResolvedDependencyResult dependent : module.getDependents()) {
        InvertedRenderableModuleResult child = new InvertedRenderableModuleResult(dependent.getFrom());
        if (!children.containsKey(child.getId())) {
            children.put(child.getId(), child);
        }
    }
    return new LinkedHashSet<RenderableDependency>(children.values());
}
 

public ResolutionResultBuilder start(final ModuleVersionIdentifier root, final ComponentIdentifier componentIdentifier) {
    store.write(new BinaryStore.WriteAction() {
        public void write(Encoder encoder) throws IOException {
            encoder.writeByte(ROOT);
            moduleVersionIdentifierSerializer.write(encoder, root);
            componentIdentifierSerializer.write(encoder, componentIdentifier);
        }
    });
    return this;
}
 

public void resolve(ConfigurationInternal configuration,
                    List<? extends ResolutionAwareRepository> repositories,
                    ModuleMetadataProcessor metadataProcessor,
                    ResolverResults results) throws ResolveException {
    if (configuration.getAllDependencies().isEmpty()) {
        ModuleVersionIdentifier id = DefaultModuleVersionIdentifier.newId(configuration.getModule());
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(configuration.getModule());
        ResolutionResult emptyResult = new DefaultResolutionResultBuilder().start(id, componentIdentifier).complete();
        results.resolved(new EmptyResolvedConfiguration(), emptyResult);
    } else {
        dependencyResolver.resolve(configuration, repositories, metadataProcessor, results);
    }
}
 

public ComponentIdentifier getComponentId() {
    return componentIdentifier;
}
 

public ComponentIdentifier getId() {
    return dependency.getActual();
}
 

public ComponentIdentifier getActual() {
    return dependency.getSelected().getId();
}
 

@Override
protected ComponentIdentifier getActual() {
    return dependency.getSelected().getId();
}
 

public RequestedVersion(ComponentSelector requested, ComponentIdentifier actual, boolean resolvable, String description) {
    this.requested = requested;
    this.actual = actual;
    this.resolvable = resolvable;
    this.description = description;
}
 

public ComponentIdentifier getComponentId() {
    return id.getComponentIdentifier();
}
 

public DefaultComponentArtifactsResult(ComponentIdentifier componentIdentifier) {
    this.componentIdentifier = componentIdentifier;
}
 

public ComponentIdentifier getId() {
    return componentId;
}
 

public DefaultModuleVersionSelection(ModuleVersionIdentifier id, ComponentSelectionReason reason, ComponentIdentifier componentIdentifier) {
    this.id = id;
    this.reason = reason;
    this.componentIdentifier = componentIdentifier;
}
 

public ComponentIdentifier getComponentIdentifier() {
    return componentIdentifier;
}
 

public ArtifactResolveException(ComponentIdentifier component, String message) {
    super(format(component, message));
}
 

public ComponentIdentifier getId() {
    return componentId;
}