* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.attributes;

import org.gradle.api.Action;

public interface CompatibilityRule<T> extends Action<CompatibilityCheckResult<T>> {
    boolean doesSomething();

            compatibilityRules.add(CompatibilityRule)
            disambiguationRules.add(DisambiguationRule)
        }
        schema.attribute(middle).with {
            compatibilityRules.add(CompatibilityRule)
            disambiguationRules.add(DisambiguationRule)
        }
        schema.attribute(lowest).with {
            compatibilityRules.add(CompatibilityRule)
            disambiguationRules.add(DisambiguationRule)

    private final DoNothingCompatibilityRule compatibilityRule = new DoNothingCompatibilityRule();
    private final DoNothingDisambiguationRule disambiguationRule = new DoNothingDisambiguationRule();

    protected EmptySchema() {
    }

    @Override
    public CompatibilityRule<Object> compatibilityRules(Attribute<?> attribute) {
        return compatibilityRule;
    }

    @Override

class DefaultCompatibilityRuleChainTest extends Specification {
    def ruleChain = new DefaultCompatibilityRuleChain(TestUtil.instantiatorFactory().inject(), SnapshotTestUtil.isolatableFactory())

    static class CompatibilityRule implements AttributeCompatibilityRule<String> {
        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            assert details.consumerValue == "value1"

import org.gradle.api.attributes.AttributesSchema
import org.gradle.api.attributes.java.TargetJvmVersion
import org.gradle.api.internal.attributes.CompatibilityCheckResult
import org.gradle.api.internal.attributes.CompatibilityRule
import org.gradle.api.internal.attributes.DefaultAttributesSchema
import org.gradle.api.internal.attributes.DisambiguationRule
import org.gradle.api.internal.attributes.MultipleCandidatesResult

    /**
     * Returns a matcher that uses the rules from this schema, and assumes the producer has the same rules.
     */
    AttributeMatcher matcher();

    CompatibilityRule<Object> compatibilityRules(Attribute<?> attribute);

    DisambiguationRule<Object> disambiguationRules(Attribute<?> attribute);

    @Nullable
    Attribute<?> getAttributeByName(String name);

    /**

    }

    @Override
    public AttributeMatcher matcher() {
        return withProducer(EmptySchema.INSTANCE);
    }

    @Override
    public CompatibilityRule<Object> compatibilityRules(Attribute<?> attribute) {
        AttributeMatchingStrategy<?> matchingStrategy = strategies.get(attribute);
        if (matchingStrategy != null) {

    }

    /**
     * This class can examine a project to determine which {@link Attribute}s in its schema have {@link org.gradle.api.internal.attributes.CompatibilityRule CompatibilityRule}s or
     * {@link org.gradle.api.internal.attributes.DisambiguationRule DisambiguationRule}s defined.
     */
    private final class ConfigurationRuleScanner {

import org.gradle.model.internal.type.ModelType;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class DefaultCompatibilityRuleChain<T> implements CompatibilityRuleChain<T>, CompatibilityRule<T> {
    private final List<Action<? super CompatibilityCheckDetails<T>>> rules = new ArrayList<>();
    private final Instantiator instantiator;
    private final IsolatableFactory isolatableFactory;

import org.gradle.api.internal.attributes.AttributeDesugaring;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.CompatibilityRule;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
import org.gradle.api.specs.Spec;