if (candidateValues.contains(javaApiJars)) {
                        details.closestMatch(javaApiJars);
                    } else if (candidateValues.contains(javaApi)) {
                        details.closestMatch(javaApi);
                    } else if (candidateValues.contains(javaRuntimeJars)) {
                        details.closestMatch(javaRuntimeJars);
                    } else if (candidateValues.contains(javaRuntime)) {

        @Override
        void execute(MultipleCandidatesDetails<String> details) {
            assert details.candidateValues == ["value1", "value2"] as Set
            details.closestMatch("value1")
        }
    }
    static class SelectionRuleWithParams implements AttributeDisambiguationRule<String> {
        String p1

        @Inject
        SelectionRuleWithParams(String p1) {

                if (details.candidateValues.contains("best")) {
                    details.closestMatch("best")
                }
            } else {
                if (details.candidateValues.contains("best")) {
                    details.closestMatch("best")
                } else {
                    details.closestMatch(details.consumerValue)
                }
            }
        }
    }

    def setup() {

                    // default to library
                    details.closestMatch(library);
                } else if (candidateValues.contains(platform)) {
                    // default to normal platform when only platforms are available and nothing has been requested
                    details.closestMatch(platform);
                }
            }
        }
    }

                    if (details.consumerValue == null) {
                        details.closestMatch(details.candidateValues.find { it.name == 'ONE' })
                    } else if (details.consumerValue.name == 'free') {
                        details.closestMatch(details.candidateValues.find { it.name == 'TWO' })
                    }
                }
            }

 *
 * <p>For a given set of rules, the execution is done <i>in order</i>, and interrupts as soon as a rule
 * selected at least one candidate (through {@link MultipleCandidatesDetails#closestMatch(Object)}).
 * </p>
 *
 * <p>If the end of the rule chain is reached and that no rule selected a candidate then the candidate list is returned
 * unmodified, meaning we still have an ambiguous match.</p>
 *

            if (details.getConsumerValue() == null) {
                Set<Usage> candidates = details.getCandidateValues();
                if (candidates.contains(runtimeUsage)) {
                    details.closestMatch(runtimeUsage);
                }
            }
        }
    }

    private static class PreferJarVariantUsageDisambiguationRule implements DisambiguationRule<LibraryElements> {

    public T getConsumerValue() {
        return consumerValue;
    }

    @Override
    public Set<T> getCandidateValues() {
        return candidateValues;
    }

    @Override
    public void closestMatch(T candidate) {
        if (singleMatch == null) {
            if (multipleMatches == null) {
                singleMatch = candidate;
            } else {
                multipleMatches.add(candidate);
            }

            }
        }
        T cmp = pickFirst ? min : max;
        if (cmp != null) {
            for (T value : candidateValues) {
                if (value.equals(cmp)) {
                    details.closestMatch(value);
                }
            }
        }
    }

     * different values, in which case it indicates that multiple candidates are equally compatible.
     *
     * @param candidate The closest match. Must be present in {@link #getCandidateValues()}.
     */
    void closestMatch(T candidate);