Java ModuleComponentIdentifier类代码示例

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
public static ModuleDescriptorState forIvyModuleDescriptor(ModuleDescriptor ivyDescriptor) {
    ModuleRevisionId moduleRevisionId = ivyDescriptor.getModuleRevisionId();
    ModuleComponentIdentifier componentIdentifier = DefaultModuleComponentIdentifier.newId(moduleRevisionId.getOrganisation(), moduleRevisionId.getName(), moduleRevisionId.getRevision());
    MutableModuleDescriptorState state = new MutableModuleDescriptorState(componentIdentifier, ivyDescriptor.getStatus(), ivyDescriptor.isDefault());

    state.setBranch(moduleRevisionId.getBranch());
    state.setDescription(ivyDescriptor.getDescription());
    state.setPublicationDate(ivyDescriptor.getPublicationDate());
    Map<NamespaceId, String> extraInfo = Cast.uncheckedCast(ivyDescriptor.getExtraInfo());
    state.getExtraInfo().putAll(extraInfo);

    for (ExcludeRule excludeRule : ivyDescriptor.getAllExcludeRules()) {
        addExcludeRule(state, excludeRule);
    }

    return state;
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
/**
 * Gets IDE repository file dependencies.
 *
 * @param configuration Configuration
 * @return IDE repository file dependencies
 */
public List<IdeExtendedRepoFileDependency> getIdeRepoFileDependencies(Configuration configuration) {
    ResolutionResult result = getIncomingResolutionResult(configuration);
    final Set<ResolvedComponentResult> resolvedRepoFileComponents = CollectionUtils.filter(result.getAllComponents(), new Spec<ResolvedComponentResult>() {
        @Override
        public boolean isSatisfiedBy(ResolvedComponentResult element) {
            return element.getId() instanceof ModuleComponentIdentifier;
        }
    });
    Set<ModuleVersionIdentifier> mappedResolvedDependencies = mapResolvedDependencies(resolvedRepoFileComponents);
    Set<ResolvedArtifact> artifacts = getExternalArtifacts(configuration);
    List<IdeExtendedRepoFileDependency> externalDependencies = new ArrayList<IdeExtendedRepoFileDependency>();
    for (ResolvedArtifact artifact : artifacts) {
        if (mappedResolvedDependencies.contains(artifact.getModuleVersion().getId())) {
            IdeExtendedRepoFileDependency ideRepoFileDependency = new IdeExtendedRepoFileDependency(artifact.getFile());
            ideRepoFileDependency.setId(artifact.getModuleVersion().getId());
            externalDependencies.add(ideRepoFileDependency);
        }
    }

    return externalDependencies;
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
public CachedMetaData getCachedModuleDescriptor(ModuleComponentRepository repository, ModuleComponentIdentifier componentId) {
    ModuleComponentAtRepositoryKey key = createKey(repository, componentId);
    ModuleMetadataCacheEntry entry = getCache().get(key);
    if (entry == null) {
        return null;
    }
    if (entry.isMissing()) {
        return new DefaultCachedMetaData(entry, null, timeProvider);
    }
    MutableModuleComponentResolveMetadata metadata = moduleMetadataStore.getModuleDescriptor(key);
    if (metadata == null) {
        // Descriptor file has been deleted - ignore the entry
        getCache().remove(key);
        return null;
    }
    return new DefaultCachedMetaData(entry, entry.configure(metadata), timeProvider);
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
protected final void resolveStaticDependency(ModuleComponentIdentifier moduleVersionIdentifier, ComponentOverrideMetadata prescribedMetaData, BuildableModuleComponentMetaDataResolveResult result, ExternalResourceArtifactResolver artifactResolver) {
    MutableModuleComponentResolveMetadata metaDataArtifactMetaData = parseMetaDataFromArtifact(moduleVersionIdentifier, artifactResolver, result);
    if (metaDataArtifactMetaData != null) {
        LOGGER.debug("Metadata file found for module '{}' in repository '{}'.", moduleVersionIdentifier, getName());
        metaDataArtifactMetaData.setSource(artifactResolver.getSource());
        result.resolved(metaDataArtifactMetaData.asImmutable());
        return;
    }

    MutableModuleComponentResolveMetadata metaDataFromDefaultArtifact = createMetaDataFromDefaultArtifact(moduleVersionIdentifier, prescribedMetaData, artifactResolver, result);
    if (metaDataFromDefaultArtifact != null) {
        LOGGER.debug("Found artifact but no meta-data for module '{}' in repository '{}', using default meta-data.", moduleVersionIdentifier, getName());
        metaDataFromDefaultArtifact.setSource(artifactResolver.getSource());
        result.resolved(metaDataFromDefaultArtifact.asImmutable());
        return;
    }

    LOGGER.debug("No meta-data file or artifact found for module '{}' in repository '{}'.", moduleVersionIdentifier, getName());
    result.missing();
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
protected void checkMetadataConsistency(ModuleComponentIdentifier expectedId, MutableModuleComponentResolveMetadata metadata) throws MetaDataParseException {
    List<String> errors = new ArrayList<String>();
    if (!expectedId.getGroup().equals(metadata.getId().getGroup())) {
        errors.add("bad group: expected='" + expectedId.getGroup() + "' found='" + metadata.getId().getGroup() + "'");
    }
    if (!expectedId.getModule().equals(metadata.getId().getName())) {
        errors.add("bad module name: expected='" + expectedId.getModule() + "' found='" + metadata.getId().getName() + "'");
    }
    if (!expectedId.getVersion().equals(metadata.getId().getVersion())) {
        errors.add("bad version: expected='" + expectedId.getVersion() + "' found='" + metadata.getId().getVersion() + "'");
    }
    if (errors.size() > 0) {
        throw new MetaDataParseException(String.format("inconsistent module metadata found. Descriptor: %s Errors: %s",
            metadata.getId(), Joiner.on(SystemProperties.getInstance().getLineSeparator()).join(errors)));
    }
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
@Override
public String getName() {
    ComponentSelector requested = getRequested();
    ComponentIdentifier selected = getActual();

    if(requested.matchesStrictly(selected)) {
        return getSimpleName();
    }

    if(requested instanceof ModuleComponentSelector && selected instanceof ModuleComponentIdentifier) {
        ModuleComponentSelector requestedModuleComponentSelector = (ModuleComponentSelector)requested;
        ModuleComponentIdentifier selectedModuleComponentedIdentifier = (ModuleComponentIdentifier)selected;

        if(isSameGroupAndModuleButDifferentVersion(requestedModuleComponentSelector, selectedModuleComponentedIdentifier)) {
            return getSimpleName() + " -> " + selectedModuleComponentedIdentifier.getVersion();
        }
    }

    return getSimpleName() + " -> " + selected.getDisplayName();
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
private static void printInfoTag(ModuleDescriptorState descriptor, SimpleXmlWriter writer) throws IOException {
    ModuleComponentIdentifier id = descriptor.getComponentIdentifier();
    writer.startElement("info");

    writer.attribute("organisation", id.getGroup());
    writer.attribute("module", id.getModule());
    String branch = descriptor.getBranch();
    if (branch != null) {
        writer.attribute("branch", branch);
    }
    writer.attribute("revision", id.getVersion());
    writer.attribute("status", descriptor.getStatus());

    if (descriptor.isGenerated()) {
        writer.attribute("default", "true");
    }

    printUnusedContent(descriptor, writer);

    for (Map.Entry<NamespaceId, String> entry : descriptor.getExtraInfo().entrySet()) {
        if (entry.getValue() == null || entry.getValue().length() == 0) {
            continue;
        }
        NamespaceId namespaceId = entry.getKey();
        writer.startElement("ns:" + namespaceId.getName());
        writer.attribute("xmlns:ns", namespaceId.getNamespace());
        writer.characters(entry.getValue());
        writer.endElement();
    }

    writer.endElement();
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
@Override
public void resolveComponentMetaData(ModuleComponentIdentifier moduleComponentIdentifier, ComponentOverrideMetadata requestMetaData, BuildableModuleComponentMetaDataResolveResult result) {
    try {
        delegate.resolveComponentMetaData(moduleComponentIdentifier, requestMetaData, result);
    } catch (Throwable throwable) {
        result.failed(new ModuleVersionResolveException(moduleComponentIdentifier, throwable));
    }
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
@Override
public void resolveComponentMetaData(ModuleComponentIdentifier moduleComponentIdentifier, ComponentOverrideMetadata requestMetaData, BuildableModuleComponentMetaDataResolveResult result) {
    super.resolveComponentMetaData(moduleComponentIdentifier, requestMetaData, result);
    if (result.getState() == BuildableModuleComponentMetaDataResolveResult.State.Resolved) {
        transformDependencies(result);
    }
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
public void resolve(ComponentIdentifier identifier, ComponentOverrideMetadata componentOverrideMetadata, BuildableComponentResolveResult result) {
    if (!(identifier instanceof ModuleComponentIdentifier)) {
        throw new UnsupportedOperationException("Can resolve meta-data for module components only.");
    }

    resolveModule((ModuleComponentIdentifier) identifier, componentOverrideMetadata, result);
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
private void resolveModule(ModuleComponentIdentifier identifier, ComponentOverrideMetadata componentOverrideMetadata, BuildableComponentResolveResult result) {
    LOGGER.debug("Attempting to resolve component for {} using repositories {}", identifier, repositoryNames);

    List<Throwable> errors = new ArrayList<Throwable>();

    List<ComponentMetaDataResolveState> resolveStates = new ArrayList<ComponentMetaDataResolveState>();
    for (ModuleComponentRepository repository : repositories) {
        resolveStates.add(new ComponentMetaDataResolveState(identifier, componentOverrideMetadata, repository, versionedComponentChooser));
    }

    final RepositoryChainModuleResolution latestResolved = findBestMatch(resolveStates, errors);
    if (latestResolved != null) {
        LOGGER.debug("Using {} from {}", latestResolved.module.getId(), latestResolved.repository);
        for (Throwable error : errors) {
            LOGGER.debug("Discarding resolve failure.", error);
        }

        result.resolved(metaDataFactory.transform(latestResolved));
        return;
    }
    if (!errors.isEmpty()) {
        result.failed(new ModuleVersionResolveException(identifier, errors));
    } else {
        for (ComponentMetaDataResolveState resolveState : resolveStates) {
            resolveState.applyTo(result);
        }
        result.notFound(identifier);
    }
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
private ModuleIdentifier getModuleIdentifier(RenderableDependency renderableDependency) {
    if (renderableDependency.getId() instanceof ModuleComponentIdentifier) {
        ModuleComponentIdentifier id = (ModuleComponentIdentifier) renderableDependency.getId();
        return new DefaultModuleIdentifier(id.getGroup(), id.getModule());
    }
    return null;
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
@Override
public void resolveComponentMetaData(ModuleComponentIdentifier moduleComponentIdentifier, ComponentOverrideMetadata requestMetaData, BuildableModuleComponentMetaDataResolveResult result) {
    if (!metaDataCache.supplyMetaData(moduleComponentIdentifier, result)) {
        super.resolveComponentMetaData(moduleComponentIdentifier, requestMetaData, result);
        metaDataCache.newDependencyResult(moduleComponentIdentifier, result);
    }
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
boolean supplyMetaData(ModuleComponentIdentifier requested, BuildableModuleComponentMetaDataResolveResult result) {
    CachedModuleVersionResult fromCache = metaData.get(requested);
    if (fromCache == null) {
        return false;
    }
    fromCache.supply(result);
    return true;
}
 

import org.gradle.api.artifacts.component.ModuleComponentIdentifier; //导入依赖的package包/类
@Override
public void resolveComponentMetaData(ModuleComponentIdentifier moduleComponentIdentifier, ComponentOverrideMetadata requestMetaData, BuildableModuleComponentMetaDataResolveResult result) {
    // First try to determine the artifacts in-memory (e.g using the metadata): don't use the cache in this case
    delegate.getLocalAccess().resolveComponentMetaData(moduleComponentIdentifier, requestMetaData, result);
    if (result.hasResult()) {
        return;
    }

    resolveComponentMetaDataFromCache(moduleComponentIdentifier, requestMetaData, result);
}