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

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

import java.lang.ref.WeakReference;

public class SpecializedMapSchema<T, E> extends ModelMapSchema<T, E> {
    private final WeakReference<Class<?>> implementationType;

    public SpecializedMapSchema(ModelType<T> type, ModelType<E> elementType, Class<?> implementationType) {
        super(type, elementType);

import org.gradle.model.internal.manage.schema.SpecializedMapSchema;
import org.gradle.model.internal.type.ModelType;

public class SpecializedMapNodeInitializer<T, E> implements NodeInitializer {
    private final SpecializedMapSchema<T, E> schema;

    public SpecializedMapNodeInitializer(SpecializedMapSchema<T, E> schema) {
        this.schema = schema;
    }

    @Override

        extractionContext.found(getModelSchema(extractionContext, elementType, proxyImpl));
    }

    private <T, E> SpecializedMapSchema<T, E> getModelSchema(ModelSchemaExtractionContext<T> extractionContext, ModelType<E> elementType, Class<?> implementationType) {
        final SpecializedMapSchema<T, E> schema = new SpecializedMapSchema<T, E>(extractionContext.getType(), elementType, implementationType);

    }

    @Override
    protected <T, E> NodeInitializer extractNodeInitializer(CollectionSchema<T, E> schema, NodeInitializerContext<T> context) {
        if (schema instanceof SpecializedMapSchema) {
            return new SpecializedMapNodeInitializer<T, E>((SpecializedMapSchema<T, E>) schema);
        }
        return null;
    }

    @Override
    public Iterable<ModelType<?>> supportedTypes() {

 * limitations under the License.
 */

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

import org.gradle.model.ModelMap
import org.gradle.model.internal.manage.schema.SpecializedMapSchema
import org.gradle.model.internal.type.ModelType
import spock.lang.Specification

class SpecializedModelMapStrategyTest extends Specification {

            final ModelRuleDescriptor descriptor = ruleDefinition.getDescriptor();

            if (modelSchema instanceof SpecializedMapSchema) {
                registration.actions(SpecializedMapNodeInitializer.getActions(ModelReference.of(modelPath), descriptor, (SpecializedMapSchema<S, ?>) modelSchema));
            } else {

    }

    interface SomeMap extends ModelMap<List<String>> {
    }

    def "specialized map"() {
        expect:
        def schema = extract(SomeMap)
        assert schema instanceof SpecializedMapSchema
        schema.elementType == new ModelType<List<String>>() {}
        schema.implementationType
    }

    private void fail(extractType, errorType, String msgPattern) {
        try {

Class <org.gradle.model.internal.manage.schema.SpecializedMapSchema> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (SpecializedMapSchema.java:0)
Class <org.gradle.model.internal.manage.schema.StructSchema> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (StructSchema.java:0)