* It does not say anything about the actual entity (e.g. its path) or the identity of the creation rule.
 *
 * @see ModelRegistrations
 */
public interface NodeInitializer {

    Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor);

import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerContext;
import org.gradle.model.internal.manage.schema.CollectionSchema;
import org.gradle.model.internal.manage.schema.ModelSchema;

public abstract class CollectionNodeInitializerExtractionSupport implements NodeInitializerExtractionStrategy {
    @Override

        }
    }

    private <T> NodeInitializer extractNodeInitializer(NodeInitializerContext<T> context) {
        ModelSchema<T> schema = schemaStore.getSchema(context.getModelType());
        for (NodeInitializerExtractionStrategy extractor : allStrategies) {
            NodeInitializer nodeInitializer = extractor.extractNodeInitializer(schema, context);
            if (nodeInitializer != null) {
                return nodeInitializer;

import org.gradle.model.internal.manage.schema.extract.NodeInitializerExtractionStrategy;

public interface NodeInitializerRegistry {
    NodeInitializer getNodeInitializer(NodeInitializerContext<?> nodeInitializerContext);

    void ensureHasInitializer(NodeInitializerContext<?> nodeInitializer);

    void registerStrategy(NodeInitializerExtractionStrategy strategy);

    }

    @Override
    public <S> NodeInitializer extractNodeInitializer(ModelSchema<S> schema, NodeInitializerContext<S> context) {
        if (!instanceFactory.getBaseInterface().isAssignableFrom(schema.getType())) {
            return null;
        }
        NodeInitializer nodeInitializer = getNodeInitializer(Cast.<ModelSchema<? extends T>>uncheckedCast(schema));
        if (nodeInitializer == null) {

import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.core.NodeBackedModelMap;
import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerRegistry;
import org.gradle.model.internal.core.SpecializedModelMapProjection;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

        private final NodeInitializer nodeInitializer;
        private final DescriptorReference descriptorReference = new DescriptorReference();
        private boolean hidden;

        private Builder(ModelPath path) {
            this(path, null);
        }

        private Builder(ModelPath path, NodeInitializer nodeInitializer) {
            this.reference = ModelReference.of(path);

    };

    @Override
    public <T> NodeInitializer extractNodeInitializer(ModelSchema<T> schema, NodeInitializerContext<T> context) {
        return super.extractNodeInitializer(schema, context);
    }

    @Override
    protected <T, E> NodeInitializer extractNodeInitializer(CollectionSchema<T, E> schema, NodeInitializerContext<T> context) {

        viewState.assertCanMutate();
        elementFilter.validateCanCreateElement(childPath, type);

        NodeInitializer nodeInitializer = creatorStrategy.initializer(type, elementFilter);

        ModelRegistrations.Builder builder = ModelRegistrations.of(childPath, nodeInitializer).descriptor(descriptor);
        if (initAction != null) {
            builder.action(ModelActionRole.Initialize, initAction);
        }

 */

package org.gradle.model.internal.manage.schema.extract;

import com.google.common.collect.ImmutableSet;
import org.gradle.model.Managed;
import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerContext;
import org.gradle.model.internal.inspect.StructNodeInitializer;
import org.gradle.model.internal.manage.binding.StructBindings;