import org.gradle.model.RuleSource; //导入依赖的package包/类
@Nullable
@Override
public <R, S> ExtractedModelRule registration(MethodRuleDefinition<R, S> ruleDefinition, MethodModelRuleExtractionContext context) {
    validateIsVoidMethod(ruleDefinition, context);
    if (ruleDefinition.getReferences().size() < 2) {
        context.add(ruleDefinition, "A method " + getDescription() + " must have at least two parameters");
        return null;
    }

    ModelType<?> ruleType = ruleDefinition.getReferences().get(0).getType();
    if (!RULE_SOURCE_MODEL_TYPE.isAssignableFrom(ruleType)) {
        context.add(ruleDefinition, "The first parameter of a method " + getDescription() + " must be a subtype of " + RuleSource.class.getName());
    }
    if (context.hasProblems()) {
        return null;
    }

    ModelType<? extends RuleSource> ruleSourceType = ruleType.asSubtype(RULE_SOURCE_MODEL_TYPE);
    RuleApplicationScope ruleApplicationScope = RuleApplicationScope.fromRuleDefinition(context, ruleDefinition, 1);
    return new ExtractedRuleSourceDefinitionRule(ruleDefinition, ruleSourceType, context.getRuleExtractor(), ruleApplicationScope);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public ModelRegistry configureMatching(final ModelSpec predicate, final Class<? extends RuleSource> rules) {
    registerListener(new DelegatingListener(predicate) {
        @Override
        public String toString() {
            return "configure matching " + predicate + " apply " + rules.getSimpleName();
        }

        @Override
        public void onDiscovered(ModelNodeInternal node) {
            if (predicate.matches(node)) {
                node.applyToSelf(rules);
            }
        }
    });
    return this;
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public Iterable<Class<? extends RuleSource>> getDeclaredSources(Class<?> container) {
    try {
        return FluentIterable.from(cache.get(container))
                .transform(new Function<Reference<Class<? extends RuleSource>>, Class<? extends RuleSource>>() {
                    @Override
                    public Class<? extends RuleSource> apply(Reference<Class<? extends RuleSource>> input) {
                        return input.get();
                    }
                })
                .filter(Predicates.notNull());
    } catch (ExecutionException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public RuleSourceApplicationAction(ModelReference<?> targetReference, ModelRuleDescriptor descriptor, List<ModelReference<?>> inputs, ModelType<? extends RuleSource> ruleSourceType, ModelRuleExtractor ruleExtractor) {
    this.targetReference = targetReference;
    this.descriptor = descriptor;
    this.inputs = inputs;
    this.ruleSourceType = ruleSourceType;
    this.ruleExtractor = ruleExtractor;
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
private <T> StructSchema<T> getSchema(Class<T> source, RuleSourceValidationProblemCollector problems) {
    if (!RuleSource.class.isAssignableFrom(source) || !source.getSuperclass().equals(RuleSource.class)) {
        problems.add("Rule source classes must directly extend " + RuleSource.class.getName());
    }

    ModelSchema<T> schema = schemaStore.getSchema(source);
    if (!(schema instanceof StructSchema)) {
        return null;
    }

    validateClass(source, problems);
    return (StructSchema<T>) schema;
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public void named(String name, Class<? extends RuleSource> ruleSource) {
    viewState.assertCanMutate();
    ModelRuleDescriptor descriptor = sourceDescriptor.append("named(%s, %s)", name, ruleSource.getName());
    ModelReference<T> subject = ModelReference.of(modelNode.getPath().child(name), elementType);
    modelNode.defineRulesForLink(ModelActionRole.Defaults, new FilteringActionWrapper<T>(elementFilter, subject, DirectNodeNoInputsModelAction.of(subject, descriptor, new ApplyRuleSource(ruleSource))));
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public void applyRules(@Nullable String pluginId, Class<?> clazz) {
    ModelRegistry modelRegistry = target.getModelRegistry();
    Iterable<Class<? extends RuleSource>> declaredSources = ruleDetector.getDeclaredSources(clazz);
    for (Class<? extends RuleSource> ruleSource : declaredSources) {
        ExtractedRuleSource<?> rules = ruleInspector.extract(ruleSource);
        for (Class<?> dependency : rules.getRequiredPlugins()) {
            target.getPluginManager().apply(dependency);
        }
        modelRegistry.getRoot().applyToSelf(rules);
    }
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public Set<Class<?>> getDeclaredSources(Class<?> container) {
    Class<?>[] declaredClasses = container.getDeclaredClasses();
    if (declaredClasses.length == 0) {
        return Collections.emptySet();
    } else {
        ImmutableSet.Builder<Class<?>> found = ImmutableSet.builder();
        for (Class<?> declaredClass : declaredClasses) {
            if (declaredClass.isAnnotationPresent(RuleSource.class)) {
                found.add(declaredClass);
            }
        }

        return found.build();
    }
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public void named(String name, Class<? extends RuleSource> ruleSource) {
    throw new UnsupportedOperationException();
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public <S> void withType(Class<S> type, Class<? extends RuleSource> rules) {
    throw new UnsupportedOperationException();
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
private boolean isRuleSource(Class<?> clazz) {
    return RuleSource.class.isAssignableFrom(clazz);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public ExtractedRuleSourceDefinitionRule(MethodRuleDefinition<?, ?> ruleDefinition, ModelType<? extends RuleSource> ruleSourceType, ModelRuleExtractor ruleExtractor, RuleApplicationScope ruleApplicationScope) {
    super(ruleDefinition);
    this.ruleSourceType = ruleSourceType;
    this.ruleExtractor = ruleExtractor;
    this.ruleApplicationScope = ruleApplicationScope;
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public void applyTo(NodePredicate predicate, Class<? extends RuleSource> rules) {
    throw new UnsupportedOperationException();
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public void applyTo(NodePredicate predicate, Class<? extends RuleSource> rules) {
    modelRegistry.configureMatching(predicate.scope(getPath()), rules);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public void applyToSelf(Class<? extends RuleSource> rulesClass) {
    ExtractedRuleSource<?> rules = modelRegistry.newRuleSource(rulesClass);
    rules.assertNoPlugins();
    rules.apply(modelRegistry, this);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public ExtractedRuleSource<?> newRuleSource(Class<? extends RuleSource> rules) {
    return ruleExtractor.extract(rules);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
@Override
public <S> void withType(Class<S> type, Class<? extends RuleSource> rules) {
    viewState.assertCanMutate();
    modelNode.applyTo(allLinks(elementFilter.withType(type)), rules);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
public ApplyRuleSource(Class<? extends RuleSource> rules) {
    this.rules = ModelType.of(rules);
}
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
/**
 * Registers a listener and applies the given {@link RuleSource} whenever a node that matches the spec is discovered.
 * Matching nodes that are already discovered when {@code configureMatching()} is called are bound directly.
 * Unlike with {@link #configure(ModelActionRole, ModelAction)}, {@link #bindAllReferences()} will <em>not</em> fail
 * if no nodes match the given spec.
 */
ModelRegistry configureMatching(ModelSpec spec, Class<? extends RuleSource> rules);
 

import org.gradle.model.RuleSource; //导入依赖的package包/类
/**
 * Applies the rules defined in the given rule source to this node.
 */
void applyToSelf(Class<? extends RuleSource> rules);