@Override
    public String toString() {
        return getDisplayName().getDisplayName();
    }

    @Override
    public void resetModel() {
        projectStateRegistry.get().discardProjectsFor(this);
        workGraphController.get().resetState();
        buildLifecycleController.get().resetModel();
        buildLifecycleController.get().getGradle().getServices().get(LifecycleAwareBuildCacheController.class).resetState();
    }

    /**
     * Runs whatever work is required prior to discarding the model for this build. Called prior to {@link #resetModel()}.
     */
    ExecutionResult<Void> beforeModelReset();

    /**
     * Restarts the lifecycle of the model of this build, discarding all current model state.
     */
    void resetModel();

    /**

        }

        cache.finalizeCacheEntry()
        buildRegistry.visitBuilds { build ->
            build.beforeModelReset().rethrow()
        }
        buildRegistry.visitBuilds { build ->
            build.resetModel()
        }

        return workGraph.withNewWorkGraph { graph ->
            val finalizedGraph = cache.loadRequestedTasks(graph, scheduleTaskSelectorPostProcessing)
            workExecutor.execute(finalizedGraph)

     */
    void addListener(Object listener);

    /**
     * Restarts the lifecycle of this build.
     */
    void resetModel();

    /**
     * Runs whatever work is required prior to discarding the model for this build. This is called prior to calling {@link #resetModel()}.
     */
    ExecutionResult<Void> beforeModelReset();

    /**

        return state.notInState(State.Finished, () -> action.apply(modelController.getConfiguredModel()));
    }

    @Override
    public void resetModel() {
        state.restart(State.ReadyToReset, State.Configure, () -> {
            gradle.resetState();
            for (HoldsProjectState service : gradle.getServices().getAll(HoldsProjectState.class)) {

        controller.finalizeWorkGraph(plan1)

        def resetResult = controller.beforeModelReset()
        resetResult.failures.empty

        controller.resetModel()

        controller.prepareToScheduleTasks()
        def plan2 = controller.newWorkGraph()
        controller.populateWorkGraph(plan2) {}
        controller.finalizeWorkGraph(plan2)

            this.workPlan = workPlan
            this.plan = plan
            this.builder = builder
            this.services = services
        }

        @Override
        void resetModel() {
        }

        @Override
        BuildWorkPlan newWorkGraph() {
            return workPlan
        }

        @Override

                            // But it was reset by the call to setVersionRange on restricting the version
                            ResolutionNode[] resetNodes = {previous, node};
                            for (int j = 0; j < 2; j++) {
                                Artifact resetArtifact = resetNodes[j].getArtifact();

                                // MNG-2123: if the previous node was not a range, then it wouldn't have any available