import java.lang.reflect.Method;

public interface ModelSchemaExtractionContext<T> extends ValidationProblemCollector {
    /**
     * Returns the type currently being inspected.
     */
    ModelType<T> getType();

    /**
     * Registers a type that should be inspected.
     */
    <C> ModelSchemaExtractionContext<C> child(ModelType<C> type, String description);

    /**

        }

        return out.toString();
    }

    public InvalidManagedModelElementTypeException(ModelSchemaExtractionContext<?> extractionContext) {
        super(getMessage((DefaultModelSchemaExtractionContext<?>) extractionContext), null);
    }

    public InvalidManagedModelElementTypeException(ModelSchemaExtractionContext<?> extractionContext, String message) {
        this(extractionContext, message, null);
    }

import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspectExtractionStrategy;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaExtractionContext;
import org.gradle.model.internal.manage.schema.extract.PropertyAccessorExtractionContext;
import org.gradle.platform.base.Variant;

import javax.annotation.Nullable;
import java.util.List;

    protected StructSchemaExtractionStrategySupport(ModelSchemaAspectExtractor aspectExtractor) {
        this.aspectExtractor = aspectExtractor;
    }

    @Override
    public <R> void extract(final ModelSchemaExtractionContext<R> extractionContext) {
        ModelType<R> type = extractionContext.getType();
        if (!isTarget(type)) {
            return;
        }

     * Potentially extracts the schema for a type. If this strategy does not recognize the type, this method should return without doing anything.
     *
     * If the strategy does recognize the type, it should call {@link ModelSchemaExtractionContext#found(org.gradle.model.internal.manage.schema.ModelSchema)} with the resulting schema, or one of the

    };

    // TODO extract common stuff from this and ModelSet and reuse

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(type)) {
            if (!type.getRawClass().equals(ModelMap.class)) {

    public final static List<Class<?>> TYPES = ImmutableList.<Class<?>>of(
        List.class,
        Set.class
    );

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        Class<? super T> rawClass = type.getRawClass();
        List<ModelType<?>> typeVariables = type.getTypeVariables();

                return generator.generate(NodeBackedModelMap.class, contractType.getConcreteClass());
            }
        });

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> modelType = extractionContext.getType();
        if (!modelType.isClass()) {
            return;
        }
        Class<?> contractType = modelType.getConcreteClass();

    private final ModelType<?> modelType;

    public ModelSetStrategy() {
        modelType = new ModelType<ModelSet<?>>() {
        };
    }

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (modelType.isAssignableFrom(type)) {
            if (!type.getRawClass().equals(ModelSet.class)) {

        Iterables.addAll(dependencyQueue, Iterables.filter(allDependencies, new Predicate<ModelSchemaExtractionContext<?>>() {
            @Override
            public boolean apply(ModelSchemaExtractionContext<?> dependency) {
                return cache.get(dependency.getType()) == null;
            }
        }));
    }