ComponentState selectedPlatformComponent = platformModule.getSelected();
        List<String> sorted = Lists.newArrayListWithCapacity(participatingModules.size() + 1);
        sorted.add(selectedPlatformComponent.getVersion());
        for (ModuleResolveState module : participatingModules) {
            ComponentState selected = module.getSelected();
            if (selected != null) {

            return
        }
        if (!visited.add(dep.getSelected())) {
            return
        }
        String reason = dep.selected.selectionReason.conflictResolution? "(C)" : "";
        sb.append(indent + dep + reason + " [" + dep.selected.dependents*.from.id.module.join(",") + "]\n");
        for (DependencyResult d : dep.getSelected().getDependencies()) {
            printNode(d, sb, visited, "  " + indent);

        return dependency.getSelected().getSelectionReason();
    }

    @Override
    public List<ResolvedVariantResult> getSelectedVariants() {
        return dependency.getSelected().getVariants();
    }

    @Override
    public List<ResolvedVariantResult> getAllVariants() {
        return ((ResolvedComponentResultInternal) dependency.getSelected()).getAvailableVariants();
    }

    @Override

    }

    @Override
    public ResolvedComponentResult getSelected() {
        return selectedComponent;
    }

    @Override
    public ResolvedVariantResult getResolvedVariant() {
        return selectedVariant;
    }

    @Override
    public String toString() {
        if (getRequested().matchesStrictly(getSelected().getId())) {
            return getRequested().toString();
        } else {

        return dependency.getSelected().getId();
    }

    @Override
    protected ComponentSelector getRequested() {
        return dependency.getRequested();
    }

    @Override
    public Set<RenderableDependency> getChildren() {
        Set<RenderableDependency> out = new LinkedHashSet<>();
        for (DependencyResult d : dependency.getSelected().getDependencies()) {

import java.util.Collection;

public interface ConflictResolverDetails<T> {
    Collection<? extends T> getCandidates();

    void select(T candidate);

    void fail(Throwable error);

    @Nullable
    T getSelected();

    @Nullable
    Throwable getFailure();

    boolean hasFailure();

    boolean hasSelected();

                encoder.writeByte(SUCCESSFUL);
                encoder.writeSmallLong(value.getSelected());
                encoder.writeSmallLong(value.getSelectedVariant());
            } else {
                encoder.writeByte(SUCCESSFUL_NOTHING_SELECTED);
                encoder.writeSmallLong(value.getSelected());
            }
        } else {
            encoder.writeByte(FAILED);

            // matching selected configuration. For the select configuration, this mean traversing its dependencies.
            resolveState.getModule(moduleIdentifier).replaceWith(result.getSelected());
        });
    }

        for (ModuleIdentifier module : participatingModules) {
            action.execute(module);
        }
    }

    @Override
    public ComponentState getSelected() {
        return selected;
    }

    @Nullable
    ModuleVersionResolveException getFailure();

    /**
     * Returns the simple id of the selected component, as per {@link ResolvedGraphComponent#getResultId()}.
     */
    @Nullable
    Long getSelected();

    /**
     * Not null only when failure is not null.
     */
    @Nullable
    ComponentSelectionReason getReason();

    boolean isConstraint();

    /**