import java.util.Set;

/**
 * Represents a component instance in the resolved dependency graph. Provides some basic identity and dependency information about the component.
 */
@UsedByScanPlugin
public interface ResolvedComponentResult extends ComponentResult {

    /**
     * <p>Returns the dependencies of this component. Includes resolved and unresolved dependencies (if any).
     *

    /**
     * Retrieves all instances of {@link ResolvedComponentResult} from the graph,
     * e.g. all nodes of the dependency graph.
     *
     * @return all nodes of the dependency graph.
     */
    Set<ResolvedComponentResult> getAllComponents();

    /**
     * Applies given action for each component.
     * An instance of {@link ResolvedComponentResult} is passed as parameter to the action.
     *

    }

    @Override
    public Set<ResolvedComponentResult> getAllComponents() {
        final Set<ResolvedComponentResult> out = new LinkedHashSet<>();
        eachElement(getRoot(), Actions.doNothing(), Actions.doNothing(), out);
        return out;
    }

    @Override
    public void allComponents(final Action<? super ResolvedComponentResult> action) {

     */
    @Nullable
    public static ResolvedComponentResult findComponent(ResolvedComponentResult rootComponent, ComponentIdentifier componentIdentifier) {
        Set<ResolvedComponentResult> seen = new HashSet<>();
        Deque<ResolvedComponentResult> pending = new ArrayDeque<>();
        pending.push(rootComponent);

        while (!pending.isEmpty()) {
            ResolvedComponentResult component = pending.pop();

    private final ConfigurationIdentity configurationIdentity;
    private final ResolutionResultProvider<ResolvedComponentResult> rootComponentProvider;

    public DefaultTransformUpstreamDependenciesResolverFactory(
        ConfigurationIdentity configurationIdentity,
        ResolutionResultProvider<ResolvedComponentResult> rootComponentProvider,
        DomainObjectContext owner,

                    writeFile("lenient-artifact-view-artifact-file", writer, it)
                }
            }
        }
    }

    protected void collectAllComponentsAndEdges(ResolvedComponentResult root, Collection<ResolvedComponentResult> components, Collection<DependencyResult> dependencies) {
        def queue = [root]
        def seen = new HashSet()

        while (!queue.isEmpty()) {

import org.gradle.api.artifacts.result.ResolvedComponentResult;

public class AbstractDependencyResult implements DependencyResult {
    private final ComponentSelector requested;
    private final ResolvedComponentResult from;
    private boolean constraint;

    public AbstractDependencyResult(ComponentSelector requested, ResolvedComponentResult from, boolean constraint) {
        assert requested != null;

import com.google.common.collect.Lists;
import org.gradle.api.artifacts.UnresolvedDependency;
import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.DependencyGraphComponent;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.DependencyGraphEdge;

    }

    @Override
    public ResolvedComponentResult getRootComponent() {
        return rootSource.get();
    }

    @Override
    public String getRepositoryId(ResolvedComponentResult resolvedComponentResult) {
        return ((ResolvedComponentResultInternal) resolvedComponentResult).getRepositoryId();
    }

    @Override

import org.gradle.api.artifacts.result.ResolvedComponentResult;
import org.gradle.api.internal.attributes.ImmutableAttributes;

import java.util.function.Supplier;

/**
 * Contains the minimal data required to construct a complete {@link org.gradle.api.artifacts.result.ResolutionResult}.
 */
public class MinimalResolutionResult {

    private final Supplier<ResolvedComponentResult> rootSource;