AllProjects result = new AllProjects();

            GradleBuild buildModel = controller.getBuildModel();
            result.rootBuild = buildModel;
            result.rootIdeaProject = controller.getModel(IdeaProject.class);

            collectAllNestedBuilds(buildModel, controller, result);

            result.allIdeaProjects.add(result.rootIdeaProject);

    ) : ToolingModelScope {
        override fun getTarget() = delegate.target

        override fun getModel(modelName: String, parameter: ToolingModelParameterCarrier?): Any? {
            return cache.loadOrCreateIntermediateModel(target?.identityPath, modelName, parameter) {
                delegate.getModel(modelName, parameter)
            }
        }
    }

        def model = withConnection(connector) { it.getModel(modelType) }
        return toGradleProject(model)
    }

    private <T> T getModelWithProjectConnection(TestFile rootDir, Class<T> modelType) {
        def connector = connector()
        connector.forProjectDirectory(rootDir.absoluteFile)
        return withConnection(connector) { it.getModel(modelType) }
    }

  std::string expected_value = "test_data";

  // Load input model
  auto input_fbm = tflite::FlatBufferModel::BuildFromFile(
      "tensorflow/lite/testdata/sparse_tensor.bin");
  tflite::ModelT input_model;
  input_fbm->GetModel()->UnPackTo(&input_model);

  // Populate input metadata
  auto model_metadata_buffer = std::make_unique<tflite::BufferT>();
  model_metadata_buffer->data =

    @Nonnull
    List<Artifact> getArtifacts();

    /**
     * Returns the project model.
     */
    @Nonnull
    Model getModel();

    /**
     * Shorthand method.
     */
    @Nonnull
    default Build getBuild() {
        Build build = getModel().getBuild();
        return build != null ? build : Build.newInstance();
    }

    /**

     * @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);
    }

import java.io.Serializable;

public class LoadEclipseModel implements BuildAction<EclipseProject>, Serializable {

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