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) {

    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;

    }

    @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;

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

public class DefaultResolvedDependencyResult extends AbstractDependencyResult implements ResolvedDependencyResult {
    private final ResolvedComponentResult selectedComponent;
    private final ResolvedVariantResult selectedVariant;

    }

    @Override
    public ResolvedComponentResult read(Decoder decoder) throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    public void write(Encoder encoder, ResolvedComponentResult value) throws Exception {
        DefaultResolvedComponentResult root = (DefaultResolvedComponentResult) value;
        Map<ResolvedComponentResult, Integer> components = new HashMap<>();