}

    public static <T> NodeInitializerContext<T> forType(ModelType<T> type) {
        return new NodeInitializerContext<T>(type, Specs.<ModelType<?>>satisfyAll(), Optional.<PropertyContext>absent());
    }

    public static <T> NodeInitializerContext<T> forExtensibleType(ModelType<T> type, Spec<ModelType<?>> constraints) {
        return new NodeInitializerContext<T>(type, constraints, Optional.<PropertyContext>absent());

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

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

    void ensureHasInitializer(NodeInitializerContext<?> nodeInitializer);

    void registerStrategy(NodeInitializerExtractionStrategy strategy);

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
    public <T> NodeInitializer extractNodeInitializer(ModelSchema<T> schema, NodeInitializerContext<T> context) {

    private final LoadingCache<NodeInitializerContext<?>, NodeInitializer> cache = CacheBuilder.newBuilder()
        .weakValues()
        .build(new CacheLoader<NodeInitializerContext<?>, NodeInitializer>() {
            @Override
            public NodeInitializer load(NodeInitializerContext<?> context) throws Exception {
                return extractNodeInitializer(context);
            }

    };

    @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) {
        if (schema instanceof SpecializedMapSchema) {

    }

    private static <T> String toMessage(NodeInitializerContext<T> context,
                                    ModelSchemaStore schemaStore,
                                    Iterable<? extends ModelType<?>> scalarTypes,
                                    Iterable<? extends ModelType<?>> constructibleTypes) {

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;
import org.gradle.model.internal.manage.binding.StructBindingsStore;

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

public interface NodeInitializerExtractionStrategy {
    <T> NodeInitializer extractNodeInitializer(ModelSchema<T> schema, NodeInitializerContext<T> context);

    Iterable<ModelType<?>> supportedTypes();

        NodeInitializerContext<C> nodeInitializerContext = forType(ModelType.of(type));
        ModelRegistration registration = ModelRegistrations.of(ModelPath.path(path), nodeInitializerRegistry.getNodeInitializer(nodeInitializerContext)).descriptor("create " + path).build();
        modelRegistry.register(registration);
        return modelRegistry;

import com.google.common.collect.ImmutableSet;
import org.gradle.api.specs.Spec;
import org.gradle.internal.Cast;
import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerContext;
import org.gradle.model.internal.inspect.FactoryBasedStructNodeInitializer;
import org.gradle.model.internal.manage.binding.StructBindings;
import org.gradle.model.internal.manage.binding.StructBindingsStore;