public InMemoryResolutionResultBuilder(boolean includeAllSelectableVariantResults) {
        this.includeAllSelectableVariantResults = includeAllSelectableVariantResults;
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        DependencyGraphComponent component = node.getOwner();
        resolutionResultBuilder.startVisitComponent(component.getResultId(), component.getSelectionReason(), component.getRepositoryName());

 * the resolution.
 */
public class FailOnVersionConflictGraphVisitor implements DependencyGraphVisitor {

    private final Set<Conflict> allConflicts = new LinkedHashSet<>();

    @Override
    public void visitNode(DependencyGraphNode node) {
        DependencyGraphComponent owner = node.getOwner();
        ComponentSelectionReason selectionReason = owner.getSelectionReason();
        if (selectionReason.isConflictResolution()) {

public interface DependencyArtifactsVisitor {
    /**
     * Visits a node in the graph. All nodes are visited prior to visiting the edges
     */
    default void visitNode(DependencyGraphNode node) {}

    /**
     * Visits the artifacts introduced by a particular edge in the graph. Called for every edge in the graph.
     * The nodes are visited in consumer-first order.
     */

        this.componentSelectorConverter = componentSelectorConverter;
    }

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

    @Override
    public void visitNode(DependencyGraphNode node) {
        for (DependencyGraphEdge dependency : node.getOutgoingEdges()) {
            ModuleVersionResolveException failure = dependency.getFailure();
            if (failure != null) {

    }

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

        return taskGraph.execute(plan);
    }

    private void bindAllReferencesOfProject(FinalizedExecutionPlan plan) {
        Set<Project> seen = new HashSet<>();
        plan.getContents().getScheduledNodes().visitNodes((nodes, entryNodes) -> {
            for (Node node : nodes) {
                if (node instanceof LocalTaskNode) {
                    ProjectInternal taskProject = node.getOwningProject();

         *
         * @param visitor the consumer of nodes and entry nodes
         */
        void visitNodes(BiConsumer<List<Node>, Set<Node>> visitor);
    }

        } else {
            modulesToBeLocked = Collections.emptyMap();
            allResolvedModules = new HashSet<>();
        }
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        boolean changing = false;
        ComponentIdentifier identifier = node.getOwner().getComponentId();
        ComponentGraphResolveMetadata metadata = node.getOwner().getMetadataOrNull();

		fmt.Fprintf(os.Stderr, "%s", errstr)
		panic("fatal error")
	}
	r.err = fmt.Errorf("%s", errstr)
	return r.err
}

// visitPod examines a coverage data 'pod', that is, a meta-data file and
// zero or more counter data files that refer to that meta-data file.
func (r *CovDataReader) visitPod(p pods.Pod) error {
	r.verb(1, "visiting pod: metafile %s with %d counter files",
		p.MetaFile, len(p.CounterDataFiles))
	r.vis.BeginPod(p)

        this.scheduledNodes = ImmutableList.copyOf(scheduledNodes);
        this.entryNodes = ImmutableSet.copyOf(entryNodes);
    }

    @Override
    public void visitNodes(BiConsumer<List<Node>, Set<Node>> visitor) {
        visitor.accept(scheduledNodes, entryNodes);
    }

    /**
     * Returns the list of the scheduled nodes in the scheduling order.
     *