AttributeMatchingStrategy<Integer> targetPlatformSchema = attributesSchema.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE);
        targetPlatformSchema.getCompatibilityRules().ordered(Ordering.natural());
        targetPlatformSchema.getDisambiguationRules().pickLast(Ordering.natural());
    }

    private static void configureTargetEnvironment(AttributesSchema attributesSchema) {

    }

    @Override
    public CompatibilityRuleChain<T> getCompatibilityRules() {
        return compatibilityRules;
    }

    @Override
    public DisambiguationRuleChain<T> getDisambiguationRules() {
        return disambiguationRules;
    }

    @Override

 * is compatible with a value provided by a candidate.
 *
 * @param <T> the type of the attribute
 * @since 3.3
 */
public interface AttributeMatchingStrategy<T> {
    CompatibilityRuleChain<T> getCompatibilityRules();

    DisambiguationRuleChain<T> getDisambiguationRules();

    /**
     * <p>A short-hand way to define both a compatibility rule and
     * a disambiguation rule based on an order defined by the provided

        AttributeMatchingStrategy<GradlePluginApiVersion> strategy = attributesSchema.attribute(GradlePluginApiVersion.GRADLE_PLUGIN_API_VERSION_ATTRIBUTE);
        strategy.getCompatibilityRules().add(TargetGradleVersionCompatibilityRule.class);
        strategy.getDisambiguationRules().add(TargetGradleVersionDisambiguationRule.class);

        final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();

        project.getDependencies().getAttributesSchema().attribute(Usage.USAGE_ATTRIBUTE).getCompatibilityRules().add(SwiftCppUsageCompatibilityRule.class);

        project.getComponents().withType(DefaultSwiftBinary.class, binary -> {
            final Names names = binary.getNames();

            final AttributeMatchingStrategy<?> matchingStrategy = attributesSchema.getMatchingStrategy(attribute);
            final DefaultCompatibilityRuleChain<?> ruleChain = (DefaultCompatibilityRuleChain<?>) matchingStrategy.getCompatibilityRules();
            return ruleChain.doesSomething();
        }

        private boolean hasDisambiguationRules(Attribute<?> attribute) {

        AttributeMatchingStrategy<?> matchingStrategy = strategies.get(attribute);
        if (matchingStrategy != null) {
            return Cast.uncheckedCast(matchingStrategy.getCompatibilityRules());
        }
        return EmptySchema.INSTANCE.compatibilityRules(attribute);
    }

    @Override
    public DisambiguationRule<Object> disambiguationRules(Attribute<?> attribute) {