Map<ResolvedGraphComponent, List<ComponentIdentifier>> shortestPaths = new LinkedHashMap<>();
        List<ComponentIdentifier> rootPath = new ArrayList<>();
        rootPath.add(toNode.getOwner().getComponentId());
        shortestPaths.put(toNode.getOwner(), rootPath);

        Set<DependencyGraphComponent> directDependees = new LinkedHashSet<>();
        for (DependencyGraphNode node : fromNodes) {

    }

    private String maybeSubstituteTimestamp(ModuleComponentArtifactMetadata artifact, String pattern) {
        if (artifact.getComponentId() instanceof MavenUniqueSnapshotComponentIdentifier) {
            MavenUniqueSnapshotComponentIdentifier snapshotId = (MavenUniqueSnapshotComponentIdentifier) artifact.getComponentId();
            pattern = pattern
                    .replaceFirst("-\\[revision]", "-" + snapshotId.getTimestampedVersion())

import org.gradle.api.artifacts.component.ModuleComponentIdentifier;

import java.util.List;

public interface ComponentVerificationMetadata {
    ModuleComponentIdentifier getComponentId();

    List<ArtifactVerificationMetadata> getArtifactVerifications();

    }

    @Override
    public void start(RootGraphNode root) {
        this.rootId = root.getOwner().getComponentId();
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        ComponentIdentifier componentId = node.getOwner().getComponentId();
        if (!rootId.equals(componentId) && componentId instanceof ProjectComponentIdentifierInternal) {

        this.componentId = componentId;
        this.attributes = attributes;
        this.capabilities = capabilities;
    }

    public ComponentIdentifier getComponentId() {
        return componentId;
    }

    public AttributeContainer getAttributes() {
        return attributes;
    }

    public ImmutableCapabilities getCapabilities() {
        return capabilities;

    }

    @Override
    public String toString() {
        return repositoryId + "," + componentId;
    }

    public ModuleComponentIdentifier getComponentId() {
        return componentId;
    }

    public String getRepositoryId() {
        return repositoryId;
    }

    @Override
    public boolean equals(Object o) {

import org.gradle.internal.component.model.ComponentGraphResolveMetadata;

import javax.annotation.Nullable;
import java.util.Set;

public interface ComponentResolutionState extends StringVersioned {
    ComponentIdentifier getComponentId();

    ModuleVersionIdentifier getId();

    /**
     * Returns the meta-data for the component. Resolves if not already resolved.
     *
     * @return null if the meta-data is not available due to some failure.

        return componentIdentifier;
    }

    @Override
    public ComponentArtifactIdentifier getId() {
        return this;
    }

    @Override
    public ComponentIdentifier getComponentId() {
        return componentIdentifier;
    }

    @Override
    public String toString() {
        return getDisplayName();
    }

    @Override
    public TaskDependency getBuildDependencies() {

 * some versions of a module are found in one repository, others in a different repository),
 * then you must look at the version thanks to the {@link #getComponentId()} method. But
 * because there can also be version listings, you must also check for {@link #getModuleId()}.
 * <p></p>
 * A {@link #isVersionListing() convenience method} makes it easier to find out if you

    ComponentGraphResolveState getResolveState();

    @Nullable
    String getRepositoryName();

    /**
     * Returns a unique id for this component.
     */
    ComponentIdentifier getComponentId();

    /**
     * Returns the module version for this component.
     */
    ModuleVersionIdentifier getModuleVersion();

    /**
     * The reason this component was selected in the graph.
     */