for (NodeState node : nodes) {
            if (node.isSelected()) {
                consumer.accept(node);
            }
        }
    }

    @Override
    public List<ComponentState> getDependents() {
        List<ComponentState> incoming = Lists.newArrayListWithCapacity(nodes.size());
        for (NodeState node : nodes) {

        });
        selectorState.update(dependencyState);
        return selectorState;
    }

    @Nullable
    public NodeState peek() {
        return queue.isEmpty() ? null : queue.getFirst();
    }

    public NodeState pop() {
        NodeState next = queue.removeFirst();
        return next.dequeue();
    }

    /**

        return pendingDependencies;
    }

    void registerConstraintProvider(NodeState node) {
        pendingDependencies.registerConstraintProvider(node);
    }

    void unregisterConstraintProvider(NodeState nodeState) {
        pendingDependencies.unregisterConstraintProvider(nodeState);
    }

    public void maybeUpdateSelection(ResolutionConflictTracker conflictTracker) {

     */
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();
        Collection<NodeState> getImplicitCapabilityProviders();
    }

    interface ResolutionDetails extends ConflictResolutionResult {
        Collection<? extends Capability> getCapabilityVersions();

	switch xdsType {
	case model.ListenerType:
		ldsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.ClusterType:
		cdsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.EndpointType:
		edsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	case model.RouteType:
		rdsReject.With(nodeTag.Value(node), errTag.Value(errCode)).Increment()
	}
}

            return (ComponentState) selected;
        }
        if (selected instanceof NodeState) {
            return ((NodeState) selected).getComponent();
        }
        throw new IllegalArgumentException("Cannot extract a ComponentState from " + selected.getClass());
    }


    private final Collection<? extends ModuleIdentifier> participatingModules;
    private final ComponentState selected;

    }

    static PotentialEdge of(ResolveState resolveState, NodeState from, ModuleComponentIdentifier toComponent, ModuleComponentSelector toSelector, ComponentIdentifier owner) {
        return of(resolveState, from, toComponent, toSelector, owner, false, true);
    }

    private collectOwnStrictVersions(NodeState node, List<String> children) {
        Set<ModuleIdentifier> constraintsSet = []
        for (String child : children) {
            node.maybeCollectStrictVersions(constraintsSet, edge(node, true, child, nextNode(), true).dependencyState)
        }
        node.storeOwnStrictVersions(constraintsSet)
    }

        private final VirtualPlatformState platformState;
        private final NodeState from;
        private final ComponentIdentifier platformId;

        public LenientPlatformConfigurationMetadata(VirtualPlatformState platform, ModuleComponentIdentifier componentId, NodeState from, @Nullable ComponentIdentifier platformId) {

        }
    }

    NodeState node(ComponentState cs) {
        def metadata = Mock(VariantGraphResolveMetadata) {
            getDependencies() >> []
            getCapabilities() >> ImmutableCapabilities.of([])
        }
        def state = Mock(VariantGraphResolveState) {
            getMetadata() >> metadata
        }

        def node = new NodeState(id++, cs, resolveState, state, true) {