this.delegate = delegate;
    }


    @Override
    public SubstitutionResult apply(DependencyMetadata dependency) {
        ComponentSelector selector = dependency.getSelector();
        return cache.computeIfAbsent(selector, s -> delegate.apply(dependency));
    }

    }

    @Override
    public ModuleVersionResolveException getFailure() {
        return failure;
    }

    @Override
    public ComponentSelector getAttempted() {
        return failure.getSelector();
    }

    @Override
    public ComponentSelectionReason getAttemptedReason() {
        return reason;
    }

    @Override
    public String toString() {

    private final String selector;

    protected AbstractVersionSelector(String selector) {
        this.selector = selector;
    }

    @Override
    public String getSelector() {
        return selector;
    }

    @Override
    public boolean accept(ComponentMetadata candidate) {
        return accept(candidate.getId().getVersion());
    }

    @Override

    public DefaultUnresolvedDependency(ModuleVersionSelector selector, Throwable problem) {
        this.selector = selector;
        this.problem = problem;
    }

    @Override
    public ModuleVersionSelector getSelector() {
        return selector;
    }

    @Override
    public Throwable getProblem() {
        return problem;
    }

    @Override
    public String toString() {

 * to determine the project coordinates.
 */
public interface ComponentSelectorConverter {
    ModuleIdentifier getModule(ComponentSelector selector);
    ModuleVersionSelector getSelector(ComponentSelector selector);

 * This information is able to be transformed into a `ModuleDependencyMetadata` instance.
 */
public abstract class ExternalDependencyDescriptor {

    public abstract ModuleComponentSelector getSelector();

    public abstract boolean isOptional();

    public abstract boolean isConstraint();

    public abstract boolean isChanging();

    public abstract boolean isTransitive();

        DependencySubstitutionInternal details = instantiator.newInstance(DefaultDependencySubstitution.class,
            componentSelectionDescriptorFactory,
            dependency.getSelector(),
            dependency.getArtifacts());
        try {
            rule.execute(details);
        } catch (Exception e) {
            return SubstitutionResult.failed(e);
        }

        if (dependencyState.getDependency().getSelector() instanceof ModuleComponentSelector) {
            ModuleComponentSelector selector = (ModuleComponentSelector) dependencyState.getDependency().getSelector();
            if (!StringUtils.isEmpty(selector.getVersionConstraint().getStrictVersion())) {
                if (constraintsSet == null) {

 */
public interface DependencyGraphEdge extends ResolvedGraphDependency {
    DependencyGraphNode getFrom();

    DependencyGraphSelector getSelector();

    boolean isTransitive();

    ExcludeSpec getExclusions();

    boolean contributesArtifacts();

    DependencyMetadata getDependencyMetadata();

    ImmutableAttributes getAttributes();

    DependencyState(DependencyMetadata dependency, ComponentSelectorConverter componentSelectorConverter) {
        this(dependency, dependency.getSelector(), Collections.emptyList(), componentSelectorConverter);
    }