* @throws InternalUnsupportedModelException When the requested model is not supported.
     * @since 1.8-rc-1
     * @deprecated 4.4. Use {@link InternalBuildControllerVersion2#getModel(Object, ModelIdentifier, Object)} instead.
     */
    @Deprecated
    BuildResult<?> getModel(Object target, ModelIdentifier modelIdentifier) throws BuildExceptionVersion1,
            InternalUnsupportedModelException;

        }
        final ModelIdentifier modelIdentifier = modelMapping.getModelIdentifierFromModelType(type);
        BuildResult<?> result;
        try {
            result = builder.getModel(modelIdentifier, new BuildCancellationTokenAdapter(operationParameters.getCancellationToken()), operationParameters);
        } catch (InternalUnsupportedModelException e) {
            throw Exceptions.unknownModel(type, e);

        listener.connectionClosed(this);
    }

    void disconnect() {
        connection.disconnect();
    }

    @Override
    public <T> T getModel(Class<T> modelType) {
        return model(modelType).get();
    }

    @Override
    public <T> void getModel(final Class<T> modelType, final ResultHandler<? super T> handler) {
        model(modelType).get(handler);
    }

    @Override

import org.gradle.tooling.model.GradleProject;

public class GetGradleProject implements BuildAction<GradleProject> {
    @Override
    public GradleProject execute(BuildController controller) {
        return controller.getModel(GradleProject.class);
    }

        setup:
        def connector = toolingApi.connector()
        ProjectConnection connection = connector.connect()
        connection.getModel(GradleProject)
        connector.disconnect()

        when:
        connection.getModel(GradleProject)

        then:
        def e = thrown(RuntimeException)
        e.message ==~ /Cannot use .* as it has been stopped./
    }

import java.io.Serializable;

public class LoadEclipseModel implements BuildAction<EclipseProject>, Serializable {

    @Override
    public EclipseProject execute(BuildController controller) {
        return controller.getModel(EclipseProject.class);
    }

import java.io.Serializable;

public class TellGradleToRunSyncTasks implements BuildAction<Void>, Serializable {

    @Override
    public Void execute(BuildController controller) {
            controller.getModel(RunEclipseSynchronizationTasks.class);
        return null;
    }

        given:
        buildFile << """
buildDir = 'custom/dir'
"""

        when:
        def project = withConnection { ProjectConnection connection ->
            connection.getModel(GradleProject)
        }

        then:
        project.buildDirectory == file('custom/dir')
    }

    def "implicit/placeholder tasks are visible from tooling api"() {
        file("settings.gradle") << """
            include "subproject"
        """

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        project.tasks*.name.containsAll rootProjectImplicitTasks
        project.findByPath(":subproject").tasks*.name.containsAll implicitTasks
    }

        connector.forProjectDirectory(new File("."));

        ProjectConnection connection = connector.connect();
        try {
            // Load the model for the project
            GradleProject project = connection.getModel(GradleProject.class);
            System.out.println("Project: " + project.getName());
            System.out.println("Tasks:");
            for (Task task : project.getTasks()) {