*/
    boolean matchesRequirements(Map<String, String> requirements);

    /**
     *
     * @return the original model wrapped by this interface
     */
    ToolchainModel getModel();

    /**
     * The organization's URL of this developer.
     */
    Property<String> getOrganizationUrl();

    /**
     * The roles of this developer.
     */
    SetProperty<String> getRoles();

    /**
     * The timezone of this developer.
     */
    Property<String> getTimezone();

    /**
     * The properties of this developer.
     */
    MapProperty<String, String> getProperties();

    }

    private void collectModelsForBuild(BuildController controller, GradleBuild build, List<CppProject> projects) {
        for (BasicGradleProject project : build.getProjects()) {
            projects.add(controller.getModel(project, CppProject.class));
        }
    }

func (sp *summaryProviderImpl) Get(ctx context.Context, updateStats bool) (*statsapi.Summary, error) {
	// TODO(timstclair): Consider returning a best-effort response if any of
	// the following errors occur.
	node, err := sp.provider.GetNode()
	if err != nil {
		return nil, fmt.Errorf("failed to get node info: %v", err)
	}
	nodeConfig := sp.provider.GetNodeConfig()
	rootStats, networkStats, err := sp.provider.GetCgroupStats("/", updateStats)
	if err != nil {

        return models;
    }

    private void collectRootModels(BuildController controller, GradleBuild build, Collection<EclipseProject> models) {
        models.add(controller.getModel(build.getRootProject(), EclipseProject.class, EclipseRuntime.class, new EclipseRuntimeAction(workspace)));

        for (GradleBuild includedBuild : build.getIncludedBuilds()) {

    private List<String> fatals = new ArrayList<>();

    public SimpleProblemCollector() {}

    public SimpleProblemCollector(Model model) {
        this.model = model;
    }

    public Model getModel() {
        return model;
    }

    public List<String> getWarnings() {
        return warnings;
    }

    public List<String> getErrors() {
        return errors;
    }

 * <pre class='autoTested'>
 * ProjectConnection connection = GradleConnector.newConnector()
 *    .forProjectDirectory(new File("someProjectFolder"))
 *    .connect();
 *
 * try {
 *    BuildEnvironment env = connection.getModel(BuildEnvironment.class);
 *    System.out.println("Gradle version: " + env.getGradle().getGradleVersion());
 *    System.out.println("Java home: " + env.getJava().getJavaHome());
 * } finally {
 *    connection.close();
 * }

     */
    State getState();

    /**
     * The actual mode of the lock. May be different to what was requested.
     */
    FileLockManager.LockMode getMode();

    /**
     * An immutable snapshot of the state of a lock.
     */
    interface State {
        boolean canDetectChanges();
        boolean isInInitialState();

    }

    public DefaultLockOptions useCrossVersionImplementation() {
        crossVersion = true;
        return this;
    }

    @Override
    public FileLockManager.LockMode getMode() {
        return mode;
    }

    @Override
    public boolean isUseCrossVersionImplementation() {
        return crossVersion;
    }

    @Override

        rootProject.name = "root"
        include 'api', 'impl', 'contrib:api', 'contrib:impl'"""

        when:

        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }

        then:
        def allNames = project.modules*.name
        allNames.unique().size() == 6

        IdeaModule impl = project.modules.find { it.name == 'root-impl' }